@vue/language-core 2.0.13 → 2.0.15

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

@@ -0,0 +1,4 @@
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateObjectProperty(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation, astHolder?: any, shouldCamelize?: boolean): Generator<Code>;

package/lib/codegen/template/objectProperty.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateObjectProperty = void 0;
+const shared_1 = require("@vue/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const interpolation_1 = require("./interpolation");
+const stringLiteralKey_1 = require("./stringLiteralKey");
+function* generateObjectProperty(options, ctx, code, offset, features, astHolder, shouldCamelize = false) {
+    if (code.startsWith('[') && code.endsWith(']') && astHolder) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, code, astHolder, offset, features, '', '');
+    }
+    else if (shouldCamelize) {
+        if (common_1.variableNameRegex.test((0, shared_1.camelize)(code))) {
+            yield* (0, camelized_1.generateCamelized)(code, offset, features);
+        }
+        else {
+            yield* (0, common_1.wrapWith)(offset, offset + code.length, features, `"`, ...(0, camelized_1.generateCamelized)(code, offset, common_1.combineLastMapping), `"`);
+        }
+    }
+    else {
+        if (common_1.variableNameRegex.test(code)) {
+            yield [code, 'template', offset, features];
+        }
+        else {
+            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, offset, features);
+        }
+    }
+}
+exports.generateObjectProperty = generateObjectProperty;
+//# sourceMappingURL=objectProperty.js.map

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

@@ -0,0 +1,4 @@
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generatePropertyAccess(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset?: number, features?: VueCodeInformation, astHolder?: any): Generator<Code>;

package/lib/codegen/template/propertyAccess.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePropertyAccess = void 0;
+const common_1 = require("../common");
+const interpolation_1 = require("./interpolation");
+const stringLiteralKey_1 = require("./stringLiteralKey");
+function* generatePropertyAccess(options, ctx, code, offset, features, astHolder) {
+    if (!options.compilerOptions.noPropertyAccessFromIndexSignature && common_1.variableNameRegex.test(code)) {
+        yield `.`;
+        yield offset !== undefined && features
+            ? [code, 'template', offset, features]
+            : code;
+    }
+    else if (code.startsWith('[') && code.endsWith(']')) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, code, astHolder, offset, features, '', '');
+    }
+    else {
+        yield `[`;
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, offset, features);
+        yield `]`;
+    }
+}
+exports.generatePropertyAccess = generatePropertyAccess;
+//# sourceMappingURL=propertyAccess.js.map

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

@@ -0,0 +1,5 @@
+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, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;

package/lib/codegen/template/slotOutlet.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSlotOutlet = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+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, 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 => {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
+            return prop.name === 'name';
+        }
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'bind'
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            return prop.arg.content === 'name';
+        }
+    });
+    if (options.hasDefineSlots) {
+        yield `__VLS_normalizeSlot(`;
+        yield* (0, common_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, common_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value
+            ? `'${nameProp.value.content}'`
+            : nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                ? nameProp.exp.content
+                : `('default' as const)`), `]`);
+        yield `)?.(`;
+        yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{${common_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true), `}`);
+        yield `)${common_1.endOfLine}`;
+        return;
+    }
+    else {
+        yield `var ${varSlot} = {${common_1.newLine}`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true);
+        yield `}${common_1.endOfLine}`;
+    }
+    if (nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE
+        && nameProp.value) {
+        ctx.slots.push({
+            name: nameProp.value.content,
+            loc: nameProp.loc.start.offset + nameProp.loc.source.indexOf(nameProp.value.content, nameProp.name.length),
+            tagRange: [startTagOffset, startTagOffset + node.tag.length],
+            varName: varSlot,
+            nodeLoc: node.loc,
+        });
+    }
+    else if (nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        const slotExpVar = ctx.getInternalVariable();
+        yield `var ${slotExpVar} = `;
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, nameProp.exp.content, nameProp.exp, nameProp.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+        yield ` as const${common_1.endOfLine}`;
+        ctx.dynamicSlots.push({
+            expVar: slotExpVar,
+            varName: varSlot,
+        });
+    }
+    else {
+        ctx.slots.push({
+            name: 'default',
+            tagRange: [startTagOffset, startTagOffset + node.tag.length],
+            varName: varSlot,
+            nodeLoc: node.loc,
+        });
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, componentCtxVar);
+}
+exports.generateSlotOutlet = generateSlotOutlet;
+//# sourceMappingURL=slotOutlet.js.map

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

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateStringLiteralKey(code: string, offset?: number, info?: VueCodeInformation): Generator<Code>;

package/lib/codegen/template/stringLiteralKey.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStringLiteralKey = void 0;
+const common_1 = require("../common");
+function* generateStringLiteralKey(code, offset, info) {
+    if (offset === undefined || !info) {
+        yield `"${code}"`;
+    }
+    else {
+        yield* (0, common_1.wrapWith)(offset, offset + code.length, info, `"`, [code, 'template', offset, common_1.combineLastMapping], `"`);
+    }
+}
+exports.generateStringLiteralKey = generateStringLiteralKey;
+//# sourceMappingURL=stringLiteralKey.js.map

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

@@ -0,0 +1,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 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

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInterpolationNode = exports.getVForNode = exports.generateTemplateChild = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+const common_1 = require("../common");
+const element_1 = require("./element");
+const interpolation_1 = require("./interpolation");
+const slotOutlet_1 = require("./slotOutlet");
+const vFor_1 = require("./vFor");
+const vIf_1 = require("./vIf");
+// @ts-ignore
+const transformContext = {
+    onError: () => { },
+    helperString: str => str.toString(),
+    replaceNode: () => { },
+    cacheHandlers: false,
+    prefixIdentifiers: false,
+    scopes: {
+        vFor: 0,
+        vOnce: 0,
+        vPre: 0,
+        vSlot: 0,
+    },
+    expressionPlugins: ['typescript'],
+};
+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]*/)) {
+            yield `// @vue-skip${common_1.newLine}`;
+            return;
+        }
+        else if (commentText.match(/^@vue-ignore\b[\s\S]*/)) {
+            yield* ctx.ignoreError();
+        }
+        else if (commentText.match(/^@vue-expect-error\b[\s\S]*/)) {
+            yield* ctx.expectError(prevNode);
+        }
+    }
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        let prev;
+        for (const childNode of node.children) {
+            yield* generateTemplateChild(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+            prev = childNode;
+        }
+        yield* ctx.resetDirectiveComments('end of root');
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        const vForNode = getVForNode(node);
+        const vIfNode = getVIfNode(node);
+        if (vForNode) {
+            yield* (0, vFor_1.generateVFor)(options, ctx, vForNode, currentComponent, componentCtxVar);
+        }
+        else if (vIfNode) {
+            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, 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.generateComponent)(options, ctx, node, currentComponent, componentCtxVar);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
+        // {{ var }}
+        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, currentComponent, undefined, componentCtxVar);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
+        // {{ ... }}
+        const [content, start] = parseInterpolationNode(node, options.template.content);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, content, node.content.loc, start, ctx.codeFeatures.all, `(`, `)${common_1.endOfLine}`);
+        yield* ctx.resetDirectiveComments('end of INTERPOLATION');
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        // v-if / v-else-if / v-else
+        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, currentComponent, componentCtxVar);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT) {
+        // not needed progress
+    }
+}
+exports.generateTemplateChild = generateTemplateChild;
+// TODO: track https://github.com/vuejs/vue-next/issues/3498
+function getVForNode(node) {
+    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'for');
+    if (forDirective) {
+        let forNode;
+        CompilerDOM.processFor(node, forDirective, transformContext, _forNode => {
+            forNode = { ..._forNode };
+            return undefined;
+        });
+        if (forNode) {
+            forNode.children = [{
+                    ...node,
+                    props: node.props.filter(prop => prop !== forDirective),
+                }];
+            return forNode;
+        }
+    }
+}
+exports.getVForNode = getVForNode;
+function getVIfNode(node) {
+    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'if');
+    if (forDirective) {
+        let ifNode;
+        CompilerDOM.processIf(node, forDirective, transformContext, _ifNode => {
+            ifNode = { ..._ifNode };
+            return undefined;
+        });
+        if (ifNode) {
+            for (const branch of ifNode.branches) {
+                branch.children = [{
+                        ...node,
+                        props: node.props.filter(prop => prop !== forDirective),
+                    }];
+            }
+            return ifNode;
+        }
+    }
+}
+function parseInterpolationNode(node, template) {
+    let content = node.content.loc.source;
+    let start = node.content.loc.start.offset;
+    let leftCharacter;
+    let rightCharacter;
+    // fix https://github.com/vuejs/language-tools/issues/1787
+    while ((leftCharacter = template.substring(start - 1, start)).trim() === '' && leftCharacter.length) {
+        start--;
+        content = leftCharacter + content;
+    }
+    while ((rightCharacter = template.substring(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
+        content = content + rightCharacter;
+    }
+    return [
+        content,
+        start,
+    ];
+}
+exports.parseInterpolationNode = parseInterpolationNode;
+//# sourceMappingURL=templateChild.js.map

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

@@ -0,0 +1,12 @@
+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, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function parseVForNode(node: CompilerDOM.ForNode): {
+    leftExpressionRange: {
+        start: number;
+        end: number;
+    } | undefined;
+    leftExpressionText: string | undefined;
+};

package/lib/codegen/template/vFor.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVForNode = exports.generateVFor = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+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, currentComponent, componentCtxVar) {
+    const { source } = node.parseResult;
+    const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
+    const forBlockVars = [];
+    yield `for (const [`;
+    if (leftExpressionRange && leftExpressionText) {
+        const collectAst = (0, common_1.createTsAst)(options.ts, node.parseResult, `const [${leftExpressionText}]`);
+        (0, common_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
+        yield [
+            leftExpressionText,
+            'template',
+            leftExpressionRange.start,
+            ctx.codeFeatures.all,
+        ];
+    }
+    yield `] of `;
+    if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        yield `__VLS_getVForSourceType(`;
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, source.content, source.loc, source.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+        yield `!)`; // #3102
+    }
+    else {
+        yield `{} as any`;
+    }
+    yield `) {${common_1.newLine}`;
+    if ((0, index_1.isFragment)(node)) {
+        yield* ctx.resetDirectiveComments('end of v-for start');
+    }
+    for (const varName of forBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+        prev = childNode;
+    }
+    for (const varName of forBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${common_1.newLine}`;
+}
+exports.generateVFor = generateVFor;
+function parseVForNode(node) {
+    const { value, key, index } = node.parseResult;
+    const leftExpressionRange = (value || key || index)
+        ? {
+            start: (value ?? key ?? index).loc.start.offset,
+            end: (index ?? key ?? value).loc.end.offset,
+        }
+        : undefined;
+    const leftExpressionText = leftExpressionRange
+        ? node.loc.source.substring(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
+        : undefined;
+    return {
+        leftExpressionRange,
+        leftExpressionText,
+    };
+}
+exports.parseVForNode = parseVForNode;
+//# sourceMappingURL=vFor.js.map

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

@@ -0,0 +1,5 @@
+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, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;

package/lib/codegen/template/vIf.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVIf = void 0;
+const language_core_1 = require("@volar/language-core");
+const CompilerDOM = require("@vue/compiler-dom");
+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, currentComponent, componentCtxVar) {
+    let originalBlockConditionsLength = ctx.blockConditions.length;
+    for (let i = 0; i < node.branches.length; i++) {
+        const branch = node.branches[i];
+        if (i === 0) {
+            yield `if `;
+        }
+        else if (branch.condition) {
+            yield `else if `;
+        }
+        else {
+            yield `else `;
+        }
+        let addedBlockCondition = false;
+        if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const codes = [
+                ...(0, interpolation_1.generateInterpolation)(options, ctx, branch.condition.content, branch.condition.loc, branch.condition.loc.start.offset, ctx.codeFeatures.all, '(', ')'),
+            ];
+            for (const code of codes) {
+                yield code;
+            }
+            ctx.blockConditions.push((0, language_core_1.toString)(codes));
+            addedBlockCondition = true;
+            yield ` `;
+        }
+        yield `{${common_1.newLine}`;
+        if ((0, index_1.isFragment)(node)) {
+            yield* ctx.resetDirectiveComments('end of v-if start');
+        }
+        let prev;
+        for (const childNode of branch.children) {
+            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+            prev = childNode;
+        }
+        yield* ctx.generateAutoImportCompletion();
+        yield `}${common_1.newLine}`;
+        if (addedBlockCondition) {
+            ctx.blockConditions[ctx.blockConditions.length - 1] = `!(${ctx.blockConditions[ctx.blockConditions.length - 1]})`;
+        }
+    }
+    ctx.blockConditions.length = originalBlockConditionsLength;
+}
+exports.generateVIf = generateVIf;
+//# sourceMappingURL=vIf.js.map

package/lib/languageModule.d.ts

@@ -1,10 +1,9 @@
 import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions, VueLanguagePlugin } from './types';
-import { VueGeneratedCode } from './virtualFile/vueFile';
-interface _Plugin extends LanguagePlugin<VueGeneratedCode> {
+import { VueVirtualCode } from './virtualFile/vueFile';
+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, codegenStack?: boolean): _Plugin;
-export {};
+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;

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) {
@@ -35,8 +38,7 @@ function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
     ];
     return JSON.stringify(values);
 }
-function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, getProjectVersion, getScriptFileNames, compilerOptions, vueCompilerOptions, codegenStack = false) {
-    const allowLanguageIds = new Set(['vue']);
+function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, getProjectVersion, getScriptFileNames, compilerOptions, vueCompilerOptions) {
     const pluginContext = {
         modules: {
             '@vue/compiler-dom': vueCompilerOptions.target < 3
@@ -49,16 +51,12 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
         },
         compilerOptions,
         vueCompilerOptions,
-        codegenStack,
         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();
@@ -67,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) {
@@ -85,7 +94,11 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
                     return code;
                 }
                 else {
-                    const code = new vueFile_1.VueGeneratedCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts, codegenStack);
+                    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;
                 }
@@ -120,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,
@@ -143,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)) {