@vue/language-core 2.0.14 → 2.0.15

package/lib/codegen/template/elementProps.js

@@ -10,9 +10,11 @@ const camelized_1 = require("./camelized");
 const interpolation_1 = require("./interpolation");
 const objectProperty_1 = require("./objectProperty");
 const language_core_1 = require("@volar/language-core");
+const elementEvents_1 = require("./elementEvents");
 function* generateElementProps(options, ctx, node, props, enableCodeFeatures, propsFailedExps) {
     let styleAttrNum = 0;
     let classAttrNum = 0;
+    const isIntrinsicElement = node.tagType === CompilerDOM.ElementTypes.ELEMENT || node.tagType === CompilerDOM.ElementTypes.TEMPLATE;
     const canCamelize = node.tagType === CompilerDOM.ElementTypes.COMPONENT;
     if (props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
         && prop.name === 'bind'
@@ -22,15 +24,38 @@ function* generateElementProps(options, ctx, node, props, enableCodeFeatures, pr
         styleAttrNum++;
         classAttrNum++;
     }
-    yield `...{ `;
-    for (const prop of props) {
-        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && prop.name === 'on'
-            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-            yield `'${(0, shared_1.camelize)('on-' + prop.arg.loc.source)}': {} as any, `;
+    if (!isIntrinsicElement) {
+        let generatedEvent = false;
+        for (const prop of props) {
+            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+                && prop.name === 'on'
+                && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                if (prop.arg.loc.source.startsWith('[') && prop.arg.loc.source.endsWith(']')) {
+                    continue;
+                }
+                if (!generatedEvent) {
+                    yield `...{ `;
+                    generatedEvent = true;
+                }
+                yield `'${(0, shared_1.camelize)('on-' + prop.arg.loc.source)}': {} as any, `;
+            }
+        }
+        if (generatedEvent) {
+            yield `}, `;
+        }
+    }
+    else {
+        for (const prop of props) {
+            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+                && prop.name === 'on'
+                && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                yield* (0, elementEvents_1.generateEventArg)(options, ctx, prop.arg, false);
+                yield `: `;
+                yield* (0, elementEvents_1.generateEventExpression)(options, ctx, prop);
+                yield `,${common_1.newLine}`;
+            }
         }
     }
-    yield `}, `;
     for (const prop of props) {
         if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
             && (prop.name === 'bind' || prop.name === 'model')
@@ -71,7 +96,7 @@ function* generateElementProps(options, ctx, node, props, enableCodeFeatures, pr
                         }
                         : false,
                 }
-                : ctx.codeFeatures.withoutHighlightAndCompletion, prop.loc.name_2 ?? (prop.loc.name_2 = {}), shouldCamelize), `: (`, ...genereatePropExp(options, ctx, prop.exp, ctx.codeFeatures.withoutHighlightAndCompletion, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
+                : ctx.codeFeatures.withoutHighlightAndCompletion, prop.loc.name_2 ?? (prop.loc.name_2 = {}), shouldCamelize), `: (`, ...genereatePropExp(options, ctx, prop.exp, ctx.codeFeatures.all, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
             if (!enableCodeFeatures) {
                 yield (0, language_core_1.toString)([...codes]);
             }

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

@@ -1,6 +1,6 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
-import type { Code, Sfc, VueCodeInformation, VueCompilerOptions } from '../../types';
+import type { Code, Sfc, VueCompilerOptions } from '../../types';
 export interface TemplateCodegenOptions {
     ts: typeof ts;
     compilerOptions: ts.CompilerOptions;
@@ -26,15 +26,15 @@ export declare function generateTemplate(options: TemplateCodegenOptions): Gener
             varName: string;
         }[];
         codeFeatures: {
-            all: VueCodeInformation;
-            verification: VueCodeInformation;
-            completion: VueCodeInformation;
-            additionalCompletion: VueCodeInformation;
-            navigation: VueCodeInformation;
-            navigationAndCompletion: VueCodeInformation;
-            withoutHighlight: VueCodeInformation;
-            withoutHighlightAndCompletion: VueCodeInformation;
-            withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
+            all: import("../../types").VueCodeInformation;
+            verification: import("../../types").VueCodeInformation;
+            completion: import("../../types").VueCodeInformation;
+            additionalCompletion: import("../../types").VueCodeInformation;
+            navigation: import("../../types").VueCodeInformation;
+            navigationAndCompletion: import("../../types").VueCodeInformation;
+            withoutHighlight: import("../../types").VueCodeInformation;
+            withoutHighlightAndCompletion: import("../../types").VueCodeInformation;
+            withoutHighlightAndCompletionAndNavigation: import("../../types").VueCodeInformation;
         };
         accessGlobalVariables: Map<string, Set<number>>;
         hasSlotElements: Set<CompilerDOM.ElementNode>;

package/lib/codegen/template/index.js

@@ -2,19 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFragment = exports.forEachElementNode = exports.generateTemplate = void 0;
 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 context_1 = require("./context");
 const element_1 = require("./element");
 const objectProperty_1 = require("./objectProperty");
-const propertyAccess_1 = require("./propertyAccess");
 const stringLiteralKey_1 = require("./stringLiteralKey");
 const templateChild_1 = require("./templateChild");
 function* generateTemplate(options) {
     const ctx = (0, context_1.createTemplateCodegenContext)();
-    const { componentTagNameOffsets, elementTagNameOffsets } = collectTagOffsets();
     let hasSlot = false;
     if (options.slotsAssignName) {
         ctx.addLocalVariable(options.slotsAssignName);
@@ -37,46 +32,6 @@ function* generateTemplate(options) {
         ctx,
         hasSlot,
     };
-    function collectTagOffsets() {
-        const componentTagNameOffsets = new Map();
-        const elementTagNameOffsets = new Map();
-        if (!options.template.ast) {
-            return {
-                componentTagNameOffsets,
-                elementTagNameOffsets,
-            };
-        }
-        for (const node of forEachElementNode(options.template.ast)) {
-            if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
-                // ignore
-                continue;
-            }
-            if (node.tag === 'component' || node.tag === 'Component') {
-                // ignore
-                continue;
-            }
-            const map = node.tagType === CompilerDOM.ElementTypes.COMPONENT
-                ? componentTagNameOffsets
-                : elementTagNameOffsets;
-            let offsets = map.get(node.tag);
-            if (!offsets) {
-                map.set(node.tag, offsets = []);
-            }
-            const source = options.template.content.substring(node.loc.start.offset);
-            const startTagOffset = node.loc.start.offset + source.indexOf(node.tag);
-            offsets.push(startTagOffset); // start tag
-            if (!node.isSelfClosing && options.template.lang === 'html') {
-                const endTagOffset = node.loc.start.offset + node.loc.source.lastIndexOf(node.tag);
-                if (endTagOffset !== startTagOffset) {
-                    offsets.push(endTagOffset); // end tag
-                }
-            }
-        }
-        return {
-            componentTagNameOffsets,
-            elementTagNameOffsets,
-        };
-    }
     function* generateSlotsType() {
         for (const { expVar, varName } of ctx.dynamicSlots) {
             hasSlot = true;
@@ -115,57 +70,21 @@ function* generateTemplate(options) {
     }
     function* generatePreResolveComponents() {
         yield `let __VLS_resolvedLocalAndGlobalComponents!: {}`;
-        for (const [tagName] of componentTagNameOffsets) {
-            const isNamespacedTag = tagName.includes('.');
-            if (isNamespacedTag) {
-                continue;
-            }
-            yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(tagName)}', typeof __VLS_localComponents, `;
-            yield (0, element_1.getPossibleOriginalComponentNames)(tagName, false)
-                .map(name => `"${name}"`)
-                .join(', ');
-            yield `>`;
-        }
-        yield common_1.endOfLine;
-        for (const [tagName, offsets] of elementTagNameOffsets) {
-            for (const tagOffset of offsets) {
-                yield `__VLS_intrinsicElements`;
-                yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, tagName, tagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
-                yield `;`;
-            }
-            yield `${common_1.newLine}`;
-        }
-        for (const [tagName, offsets] of componentTagNameOffsets) {
-            if (!common_1.variableNameRegex.test((0, shared_1.camelize)(tagName))) {
-                continue;
-            }
-            for (const tagOffset of offsets) {
-                for (const shouldCapitalize of (tagName[0] === tagName[0].toUpperCase() ? [false] : [true, false])) {
-                    const expectName = shouldCapitalize ? (0, shared_1.capitalize)((0, shared_1.camelize)(tagName)) : (0, shared_1.camelize)(tagName);
-                    yield `__VLS_components.`;
-                    yield* (0, camelized_1.generateCamelized)(shouldCapitalize ? (0, shared_1.capitalize)(tagName) : tagName, tagOffset, {
-                        navigation: {
-                            resolveRenameNewName: tagName !== expectName ? camelizeComponentName : undefined,
-                            resolveRenameEditText: getTagRenameApply(tagName),
-                        },
-                    });
-                    yield `;`;
+        if (options.template.ast) {
+            for (const node of forEachElementNode(options.template.ast)) {
+                if (node.tagType === CompilerDOM.ElementTypes.COMPONENT
+                    && node.tag.toLowerCase() !== 'component'
+                    && !node.tag.includes('.') // namespace tag 
+                ) {
+                    yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(node.tag)}', typeof __VLS_localComponents, `;
+                    yield (0, element_1.getPossibleOriginalComponentNames)(node.tag, false)
+                        .map(name => `"${name}"`)
+                        .join(', ');
+                    yield `>`;
                 }
             }
-            yield `${common_1.newLine}`;
-            yield `// @ts-ignore${common_1.newLine}`; // #2304
-            yield `[`;
-            for (const tagOffset of offsets) {
-                yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(tagName), tagOffset, {
-                    completion: {
-                        isAdditional: true,
-                        onlyImport: true,
-                    },
-                });
-                yield `,`;
-            }
-            yield `]${common_1.endOfLine}`;
         }
+        yield common_1.endOfLine;
     }
 }
 exports.generateTemplate = generateTemplate;
@@ -204,12 +123,6 @@ function* forEachElementNode(node) {
     }
 }
 exports.forEachElementNode = forEachElementNode;
-function camelizeComponentName(newName) {
-    return (0, shared_1.camelize)('-' + newName);
-}
-function getTagRenameApply(oldName) {
-    return oldName === (0, shared_2.hyphenateTag)(oldName) ? shared_2.hyphenateTag : undefined;
-}
 function isFragment(node) {
     return node.codegenNode && 'consequent' in node.codegenNode && 'tag' in node.codegenNode.consequent && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
 }

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

@@ -2,4 +2,4 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateSlotOutlet(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.SlotOutletNode, currentElement: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateSlotOutlet(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.SlotOutletNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;

package/lib/codegen/template/slotOutlet.js

@@ -6,7 +6,7 @@ const common_1 = require("../common");
 const elementChildren_1 = require("./elementChildren");
 const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
-function* generateSlotOutlet(options, ctx, node, currentElement, componentCtxVar) {
+function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxVar) {
     const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
     const varSlot = ctx.getInternalVariable();
     const nameProp = node.props.find(prop => {
@@ -66,7 +66,7 @@ function* generateSlotOutlet(options, ctx, node, currentElement, componentCtxVar
         });
     }
     yield* ctx.generateAutoImportCompletion();
-    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentElement, componentCtxVar);
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, componentCtxVar);
 }
 exports.generateSlotOutlet = generateSlotOutlet;
 //# sourceMappingURL=slotOutlet.js.map

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

@@ -2,6 +2,6 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, currentElement: CompilerDOM.ElementNode | undefined, prevNode: CompilerDOM.TemplateChildNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, currentComponent: CompilerDOM.ElementNode | undefined, prevNode: CompilerDOM.TemplateChildNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
 export declare function getVForNode(node: CompilerDOM.ElementNode): CompilerDOM.ForNode | undefined;
 export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];

package/lib/codegen/template/templateChild.js

@@ -23,7 +23,7 @@ const transformContext = {
     },
     expressionPlugins: ['typescript'],
 };
-function* generateTemplateChild(options, ctx, node, currentElement, prevNode, componentCtxVar) {
+function* generateTemplateChild(options, ctx, node, currentComponent, prevNode, componentCtxVar) {
     if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
         const commentText = prevNode.content.trim().split(' ')[0];
         if (commentText.match(/^@vue-skip\b[\s\S]*/)) {
@@ -40,7 +40,7 @@ function* generateTemplateChild(options, ctx, node, currentElement, prevNode, co
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
         let prev;
         for (const childNode of node.children) {
-            yield* generateTemplateChild(options, ctx, childNode, currentElement, prev, componentCtxVar);
+            yield* generateTemplateChild(options, ctx, childNode, currentComponent, prev, componentCtxVar);
             prev = childNode;
         }
         yield* ctx.resetDirectiveComments('end of root');
@@ -49,29 +49,33 @@ function* generateTemplateChild(options, ctx, node, currentElement, prevNode, co
         const vForNode = getVForNode(node);
         const vIfNode = getVIfNode(node);
         if (vForNode) {
-            yield* (0, vFor_1.generateVFor)(options, ctx, vForNode, currentElement, componentCtxVar);
+            yield* (0, vFor_1.generateVFor)(options, ctx, vForNode, currentComponent, componentCtxVar);
         }
         else if (vIfNode) {
-            yield* (0, vIf_1.generateVIf)(options, ctx, vIfNode, currentElement, componentCtxVar);
+            yield* (0, vIf_1.generateVIf)(options, ctx, vIfNode, currentComponent, componentCtxVar);
         }
         else {
             if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
-                yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node, currentElement, componentCtxVar);
+                yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node, currentComponent, componentCtxVar);
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
+                || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
+                yield* (0, element_1.generateElement)(options, ctx, node, currentComponent, componentCtxVar);
             }
             else {
-                yield* (0, element_1.generateElement)(options, ctx, node, currentElement, componentCtxVar);
+                yield* (0, element_1.generateComponent)(options, ctx, node, currentComponent, componentCtxVar);
             }
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
         // {{ var }}
-        yield* generateTemplateChild(options, ctx, node.content, currentElement, undefined, componentCtxVar);
+        yield* generateTemplateChild(options, ctx, node.content, currentComponent, undefined, componentCtxVar);
     }
     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
         // {{ ... }} {{ ... }}
         for (const childNode of node.children) {
             if (typeof childNode === 'object') {
-                yield* generateTemplateChild(options, ctx, childNode, currentElement, undefined, componentCtxVar);
+                yield* generateTemplateChild(options, ctx, childNode, currentComponent, undefined, componentCtxVar);
             }
         }
     }
@@ -83,11 +87,11 @@ function* generateTemplateChild(options, ctx, node, currentElement, prevNode, co
     }
     else if (node.type === CompilerDOM.NodeTypes.IF) {
         // v-if / v-else-if / v-else
-        yield* (0, vIf_1.generateVIf)(options, ctx, node, currentElement, componentCtxVar);
+        yield* (0, vIf_1.generateVIf)(options, ctx, node, currentComponent, componentCtxVar);
     }
     else if (node.type === CompilerDOM.NodeTypes.FOR) {
         // v-for
-        yield* (0, vFor_1.generateVFor)(options, ctx, node, currentElement, componentCtxVar);
+        yield* (0, vFor_1.generateVFor)(options, ctx, node, currentComponent, componentCtxVar);
     }
     else if (node.type === CompilerDOM.NodeTypes.TEXT) {
         // not needed progress

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

@@ -2,7 +2,7 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateVFor(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ForNode, currentElement: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateVFor(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ForNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
 export declare function parseVForNode(node: CompilerDOM.ForNode): {
     leftExpressionRange: {
         start: number;

package/lib/codegen/template/vFor.js

@@ -6,7 +6,7 @@ const common_1 = require("../common");
 const index_1 = require("./index");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
-function* generateVFor(options, ctx, node, currentElement, componentCtxVar) {
+function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
     const { source } = node.parseResult;
     const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
     const forBlockVars = [];
@@ -39,7 +39,7 @@ function* generateVFor(options, ctx, node, currentElement, componentCtxVar) {
     }
     let prev;
     for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentElement, prev, componentCtxVar);
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
         prev = childNode;
     }
     for (const varName of forBlockVars) {

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

@@ -2,4 +2,4 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateVIf(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.IfNode, currentElement: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateVIf(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.IfNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;

package/lib/codegen/template/vIf.js

@@ -7,7 +7,7 @@ const common_1 = require("../common");
 const index_1 = require("./index");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
-function* generateVIf(options, ctx, node, currentElement, componentCtxVar) {
+function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
     let originalBlockConditionsLength = ctx.blockConditions.length;
     for (let i = 0; i < node.branches.length; i++) {
         const branch = node.branches[i];
@@ -38,7 +38,7 @@ function* generateVIf(options, ctx, node, currentElement, componentCtxVar) {
         }
         let prev;
         for (const childNode of branch.children) {
-            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentElement, prev, componentCtxVar);
+            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
             prev = childNode;
         }
         yield* ctx.generateAutoImportCompletion();

package/lib/languageModule.d.ts

@@ -2,9 +2,8 @@ import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions, VueLanguagePlugin } from './types';
 import { VueVirtualCode } from './virtualFile/vueFile';
-interface _Plugin extends LanguagePlugin<VueVirtualCode> {
+export interface _Plugin extends LanguagePlugin<VueVirtualCode> {
     getCanonicalFileName: (fileName: string) => string;
     pluginContext: Parameters<VueLanguagePlugin>[0];
 }
 export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (fileId: string) => string, useCaseSensitiveFileNames: boolean, getProjectVersion: () => string, getScriptFileNames: () => string[] | Set<string>, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): _Plugin;
-export {};

package/lib/languageModule.js

@@ -6,6 +6,9 @@ const plugins_1 = require("./plugins");
 const vueFile_1 = require("./virtualFile/vueFile");
 const CompilerDOM = require("@vue/compiler-dom");
 const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+const file_html_1 = require("./plugins/file-html");
+const file_md_1 = require("./plugins/file-md");
+const file_vue_1 = require("./plugins/file-vue");
 const normalFileRegistries = [];
 const holderFileRegistries = [];
 function getVueFileRegistry(isGlobalTypesHolder, key, plugins) {
@@ -36,7 +39,6 @@ function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
     return JSON.stringify(values);
 }
 function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, getProjectVersion, getScriptFileNames, compilerOptions, vueCompilerOptions) {
-    const allowLanguageIds = new Set(['vue']);
     const pluginContext = {
         modules: {
             '@vue/compiler-dom': vueCompilerOptions.target < 3
@@ -51,13 +53,10 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
         vueCompilerOptions,
         globalTypesHolder: undefined,
     };
-    const plugins = (0, plugins_1.getDefaultVueLanguagePlugins)(pluginContext);
-    if (vueCompilerOptions.extensions.includes('.md')) {
-        allowLanguageIds.add('markdown');
-    }
-    if (vueCompilerOptions.extensions.includes('.html')) {
-        allowLanguageIds.add('html');
-    }
+    const basePlugins = (0, plugins_1.getBasePlugins)(pluginContext);
+    const vueSfcPlugin = (0, file_vue_1.default)(pluginContext);
+    const vitePressSfcPlugin = (0, file_md_1.default)(pluginContext);
+    const petiteVueSfcPlugin = (0, file_html_1.default)(pluginContext);
     const getCanonicalFileName = useCaseSensitiveFileNames
         ? (fileName) => fileName
         : (fileName) => fileName.toLowerCase();
@@ -66,8 +65,19 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
     return {
         getCanonicalFileName,
         pluginContext,
+        getLanguageId(scriptId) {
+            if (vueCompilerOptions.extensions.some(ext => scriptId.endsWith(ext))) {
+                return 'vue';
+            }
+            if (vueCompilerOptions.vitePressExtensions.some(ext => scriptId.endsWith(ext))) {
+                return 'markdown';
+            }
+            if (vueCompilerOptions.petiteVueExtensions.some(ext => scriptId.endsWith(ext))) {
+                return 'html';
+            }
+        },
         createVirtualCode(fileId, languageId, snapshot) {
-            if (allowLanguageIds.has(languageId)) {
+            if (languageId === 'vue' || languageId === 'markdown' || languageId === 'html') {
                 const fileName = getFileName(fileId);
                 const projectVersion = getProjectVersion();
                 if (projectVersion !== canonicalRootFileNamesVersion) {
@@ -84,7 +94,11 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
                     return code;
                 }
                 else {
-                    const code = new vueFile_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
+                    const code = new vueFile_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, languageId === 'html'
+                        ? [petiteVueSfcPlugin, ...basePlugins]
+                        : languageId === 'markdown'
+                            ? [vitePressSfcPlugin, ...basePlugins]
+                            : [vueSfcPlugin, ...basePlugins], ts);
                     fileRegistry.set(fileId, code);
                     return code;
                 }
@@ -119,7 +133,11 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
         // 	}
         // },
         typescript: {
-            extraFileExtensions: vueCompilerOptions.extensions.map(ext => ({
+            extraFileExtensions: [
+                ...vueCompilerOptions.extensions,
+                ...vueCompilerOptions.vitePressExtensions,
+                ...vueCompilerOptions.petiteVueExtensions,
+            ].map(ext => ({
                 extension: ext.slice(1),
                 isMixedContent: true,
                 scriptKind: 7,
@@ -142,7 +160,7 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
         },
     };
     function getFileRegistry(isGlobalTypesHolder) {
-        return getVueFileRegistry(isGlobalTypesHolder, getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
+        return getVueFileRegistry(isGlobalTypesHolder, getFileRegistryKey(compilerOptions, vueCompilerOptions, basePlugins), vueCompilerOptions.plugins);
     }
 }
 exports.createVueLanguagePlugin = createVueLanguagePlugin;

package/lib/parsers/scriptSetupRanges.d.ts

@@ -20,6 +20,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     };
     slots: {
         name?: string | undefined;
+        isObjectBindingPattern?: boolean | undefined;
         define?: (TextRange & {
             arg?: TextRange | undefined;
             typeArg?: TextRange | undefined;

package/lib/parsers/scriptSetupRanges.js

@@ -139,7 +139,12 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
                 slots.define = parseDefineFunction(node);
                 if (ts.isVariableDeclaration(parent)) {
-                    slots.name = getNodeText(ts, parent.name, ast);
+                    if (ts.isIdentifier(parent.name)) {
+                        slots.name = getNodeText(ts, parent.name, ast);
+                    }
+                    else {
+                        slots.isObjectBindingPattern = ts.isObjectBindingPattern(parent.name);
+                    }
                 }
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {