@vue/language-core 1.9.0-alpha.3 → 2.0.1

package/lib/plugins/vue-sfc-scripts.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-sfc-scripts.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../generators/utils");
+const plugin = () => {
+    return {
+        version: 2,
+        getEmbeddedCodes(_fileName, sfc) {
+            const names = [];
+            if (sfc.script) {
+                names.push({ id: 'scriptFormat', lang: sfc.script.lang });
+            }
+            if (sfc.scriptSetup) {
+                names.push({ id: 'scriptSetupFormat', lang: sfc.scriptSetup.lang });
+            }
+            return names;
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            const script = embeddedFile.id === 'scriptFormat' ? sfc.script
+                : embeddedFile.id === 'scriptSetupFormat' ? sfc.scriptSetup
+                    : undefined;
+            if (script) {
+                embeddedFile.content.push([
+                    script.content,
+                    script.name,
+                    0,
+                    (0, utils_1.disableAllFeatures)({
+                        structure: true,
+                        format: true,
+                    }),
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-scripts.js.map

package/lib/plugins/vue-sfc-styles.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-sfc-styles.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../generators/utils");
+const plugin = () => {
+    return {
+        version: 2,
+        getEmbeddedCodes(_fileName, sfc) {
+            return sfc.styles.map((style, i) => ({
+                id: 'style_' + i,
+                lang: style.lang,
+            }));
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (embeddedFile.id.startsWith('style_')) {
+                const index = parseInt(embeddedFile.id.slice('style_'.length));
+                const style = sfc.styles[index];
+                embeddedFile.content.push([
+                    style.content,
+                    style.name,
+                    0,
+                    (0, utils_1.enableAllFeatures)({}),
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-styles.js.map

package/lib/plugins/vue-sfc-template.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-sfc-template.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../generators/utils");
+const plugin = () => {
+    return {
+        version: 2,
+        getEmbeddedCodes(_fileName, sfc) {
+            if (sfc.template) {
+                return [{
+                        id: 'template',
+                        lang: sfc.template.lang,
+                    }];
+            }
+            return [];
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (embeddedFile.id === 'template' && sfc.template) {
+                embeddedFile.content.push([
+                    sfc.template.content,
+                    sfc.template.name,
+                    0,
+                    (0, utils_1.enableAllFeatures)({}),
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-template.js.map

package/lib/plugins/vue-template-html.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/{out → lib}/plugins/vue-template-html.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = ({ modules }) => {
     return {
-        version: 1,
+        version: 2,
         compileSFCTemplate(lang, template, options) {
             if (lang === 'html') {
                 const compiler = modules['@vue/compiler-dom'];
@@ -19,7 +19,7 @@ const plugin = ({ modules }) => {
             if (tryUpdateNode(oldResult.ast) && hitNodes.length) {
                 hitNodes = hitNodes.sort((a, b) => a.loc.source.length - b.loc.source.length);
                 const hitNode = hitNodes[0];
-                if (hitNode.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */) {
+                if (hitNode.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                     return oldResult;
                 }
             }
@@ -28,14 +28,14 @@ const plugin = ({ modules }) => {
                     hitNodes.push(node);
                 }
                 if (tryUpdateNodeLoc(node.loc)) {
-                    if (node.type === 0 /* CompilerDOM.NodeTypes.ROOT */) {
+                    if (node.type === CompilerDOM.NodeTypes.ROOT) {
                         for (const child of node.children) {
                             if (!tryUpdateNode(child)) {
                                 return false;
                             }
                         }
                     }
-                    else if (node.type === 1 /* CompilerDOM.NodeTypes.ELEMENT */) {
+                    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
                         if (withinChangeRange(node.loc)) {
                             // if not self closing, should not hit tag name
                             const start = node.loc.start.offset + 2;
@@ -55,12 +55,12 @@ const plugin = ({ modules }) => {
                             }
                         }
                     }
-                    else if (node.type === 6 /* CompilerDOM.NodeTypes.ATTRIBUTE */) {
+                    else if (node.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
                         if (node.value && !tryUpdateNode(node.value)) {
                             return false;
                         }
                     }
-                    else if (node.type === 7 /* CompilerDOM.NodeTypes.DIRECTIVE */) {
+                    else if (node.type === CompilerDOM.NodeTypes.DIRECTIVE) {
                         if (node.arg && withinChangeRange(node.arg.loc) && node.name === 'slot') {
                             return false;
                         }
@@ -74,12 +74,12 @@ const plugin = ({ modules }) => {
                             return false;
                         }
                     }
-                    else if (node.type === 12 /* CompilerDOM.NodeTypes.TEXT_CALL */) {
+                    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
                         if (!tryUpdateNode(node.content)) {
                             return false;
                         }
                     }
-                    else if (node.type === 8 /* CompilerDOM.NodeTypes.COMPOUND_EXPRESSION */) {
+                    else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
                         for (const childNode of node.children) {
                             if (typeof childNode === 'object') {
                                 if (!tryUpdateNode(childNode)) {
@@ -88,7 +88,7 @@ const plugin = ({ modules }) => {
                             }
                         }
                     }
-                    else if (node.type === 9 /* CompilerDOM.NodeTypes.IF */) {
+                    else if (node.type === CompilerDOM.NodeTypes.IF) {
                         for (const branch of node.branches) {
                             if (branch.condition && !tryUpdateNode(branch.condition)) {
                                 return false;
@@ -100,7 +100,7 @@ const plugin = ({ modules }) => {
                             }
                         }
                     }
-                    else if (node.type === 11 /* CompilerDOM.NodeTypes.FOR */) {
+                    else if (node.type === CompilerDOM.NodeTypes.FOR) {
                         for (const child of [
                             node.parseResult.source,
                             node.parseResult.value,
@@ -117,12 +117,12 @@ const plugin = ({ modules }) => {
                             }
                         }
                     }
-                    else if (node.type === 5 /* CompilerDOM.NodeTypes.INTERPOLATION */) {
+                    else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
                         if (!tryUpdateNode(node.content)) {
                             return false;
                         }
                     }
-                    else if (node.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */) {
+                    else if (node.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                         if (withinChangeRange(node.loc)) { // TODO: review this (slot name?)
                             if (node.isStatic) {
                                 return false;

package/{out → lib}/plugins/vue-tsx.d.ts

@@ -1,13 +1,13 @@
-import { Sfc, VueLanguagePlugin } from '../types';
-import * as muggle from 'muggle-string';
+import { Mapping, StackNode } from '@volar/language-core';
+import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
     scriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
-            argsNode: import("typescript/lib/tsserverlibrary").ObjectLiteralExpression | undefined;
+            argsNode: import("typescript").ObjectLiteralExpression | undefined;
             componentsOption: import("../types").TextRange | undefined;
-            componentsOptionNode: import("typescript/lib/tsserverlibrary").ObjectLiteralExpression | undefined;
+            componentsOptionNode: import("typescript").ObjectLiteralExpression | undefined;
             nameOption: import("../types").TextRange | undefined;
         }) | undefined;
         bindings: import("../types").TextRange[];
@@ -19,9 +19,10 @@ export declare const tsCodegen: WeakMap<Sfc, {
         props: {
             name?: string | undefined;
             define?: (import("../types").TextRange & {
-                statement: import("../types").TextRange;
                 arg?: import("../types").TextRange | undefined;
                 typeArg?: import("../types").TextRange | undefined;
+            } & {
+                statement: import("../types").TextRange;
             }) | undefined;
             withDefaults?: (import("../types").TextRange & {
                 arg?: import("../types").TextRange | undefined;
@@ -29,11 +30,17 @@ export declare const tsCodegen: WeakMap<Sfc, {
         };
         slots: {
             name?: string | undefined;
-            define?: import("../types").TextRange | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
         };
         emits: {
             name?: string | undefined;
-            define?: import("../types").TextRange | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
         };
         expose: {
             name?: string | undefined;
@@ -48,26 +55,26 @@ export declare const tsCodegen: WeakMap<Sfc, {
             type: import("../types").TextRange | undefined;
             defaultValue: import("../types").TextRange | undefined;
             required: boolean;
+            isModel?: boolean | undefined;
         }[];
     } | undefined;
     lang: () => string;
     generatedScript: () => {
-        codes: muggle.Segment<import("@volar/language-core").FileRangeCapabilities>[];
-        codeStacks: muggle.StackNode[];
-        mirrorBehaviorMappings: import("@volar/source-map").Mapping<[import("@volar/language-core").MirrorBehaviorCapabilities, import("@volar/language-core").MirrorBehaviorCapabilities]>[];
+        codes: Code[];
+        codeStacks: StackNode[];
+        linkedCodeMappings: Mapping<any>[];
     };
     generatedTemplate: () => {
-        codes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
-        codeStacks: muggle.StackNode[];
-        formatCodes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
-        formatCodeStacks: muggle.StackNode[];
-        cssCodes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
-        cssCodeStacks: muggle.StackNode[];
-        tagNames: Record<string, number[]>;
+        codes: Code[];
+        codeStacks: string[];
+        formatCodes: Code[];
+        formatCodeStacks: string[];
+        cssCodes: Code[];
+        cssCodeStacks: string[];
+        tagOffsetsMap: Map<string, number[]>;
         accessedGlobalVariables: Set<string>;
         hasSlot: boolean;
     } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;
-//# sourceMappingURL=vue-tsx.d.ts.map

package/lib/plugins/vue-tsx.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsCodegen = void 0;
+const language_core_1 = require("@volar/language-core");
+const computeds_1 = require("computeds");
+const script_1 = require("../generators/script");
+const template_1 = require("../generators/template");
+const utils_1 = require("../generators/utils");
+const scriptRanges_1 = require("../parsers/scriptRanges");
+const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+exports.tsCodegen = new WeakMap();
+const plugin = (ctx) => {
+    return {
+        version: 2,
+        requiredCompilerOptions: [
+            'noPropertyAccessFromIndexSignature',
+            'exactOptionalPropertyTypes',
+        ],
+        getEmbeddedCodes(fileName, sfc) {
+            const tsx = useTsx(fileName, sfc);
+            const files = [];
+            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang())) {
+                files.push({ id: 'script_' + tsx.lang(), lang: tsx.lang() });
+            }
+            if (sfc.template) {
+                files.push({ id: 'template_format', lang: 'ts' });
+                files.push({ id: 'template_style', lang: 'css' });
+            }
+            return files;
+        },
+        resolveEmbeddedCode(fileName, sfc, embeddedFile) {
+            const _tsx = useTsx(fileName, sfc);
+            if (embeddedFile.id.startsWith('script_')) {
+                const tsx = _tsx.generatedScript();
+                if (tsx) {
+                    const [content, contentStacks] = ctx.codegenStack ? (0, language_core_1.track)([...tsx.codes], [...tsx.codeStacks]) : [[...tsx.codes], [...tsx.codeStacks]];
+                    content.forEach(code => {
+                        if (typeof code !== 'string') {
+                            code[3].structure = false;
+                            code[3].format = false;
+                        }
+                    });
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                    embeddedFile.linkedCodeMappings = [...tsx.linkedCodeMappings];
+                }
+            }
+            else if (embeddedFile.id === 'template_format') {
+                embeddedFile.parentCodeId = 'template';
+                const template = _tsx.generatedTemplate();
+                if (template) {
+                    const [content, contentStacks] = ctx.codegenStack
+                        ? (0, language_core_1.track)([...template.formatCodes], template.formatCodeStacks.map(stack => ({ stack, length: 1 })))
+                        : [[...template.formatCodes], template.formatCodeStacks.map(stack => ({ stack, length: 1 }))];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                }
+                for (const style of sfc.styles) {
+                    embeddedFile.content.push('\n\n');
+                    for (const cssVar of style.cssVars) {
+                        embeddedFile.content.push('(');
+                        embeddedFile.content.push([
+                            cssVar.text,
+                            style.name,
+                            cssVar.offset,
+                            (0, utils_1.enableAllFeatures)({}),
+                        ]);
+                        embeddedFile.content.push(');\n');
+                    }
+                }
+            }
+            else if (embeddedFile.id === 'template_style') {
+                embeddedFile.parentCodeId = 'template';
+                const template = _tsx.generatedTemplate();
+                if (template) {
+                    const [content, contentStacks] = ctx.codegenStack
+                        ? (0, language_core_1.track)([...template.cssCodes], template.cssCodeStacks.map(stack => ({ stack, length: 1 })))
+                        : [[...template.cssCodes], template.cssCodeStacks.map(stack => ({ stack, length: 1 }))];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                }
+            }
+        },
+    };
+    function useTsx(fileName, sfc) {
+        if (!exports.tsCodegen.has(sfc)) {
+            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx));
+        }
+        return exports.tsCodegen.get(sfc);
+    }
+};
+exports.default = plugin;
+function createTsx(fileName, _sfc, ctx) {
+    const ts = ctx.modules.typescript;
+    const lang = (0, computeds_1.computed)(() => {
+        return !_sfc.script && !_sfc.scriptSetup ? 'ts'
+            : _sfc.scriptSetup && _sfc.scriptSetup.lang !== 'js' ? _sfc.scriptSetup.lang
+                : _sfc.script && _sfc.script.lang !== 'js' ? _sfc.script.lang
+                    : 'js';
+    });
+    const scriptRanges = (0, computeds_1.computed)(() => _sfc.script
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
+        : undefined);
+    const scriptSetupRanges = (0, computeds_1.computed)(() => _sfc.scriptSetup
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, ctx.vueCompilerOptions)
+        : undefined);
+    const shouldGenerateScopedClasses = (0, computeds_1.computed)(() => {
+        const option = ctx.vueCompilerOptions.experimentalResolveStyleCssClasses;
+        return _sfc.styles.some(s => {
+            return option === 'always' || (option === 'scoped' && s.scoped);
+        });
+    });
+    const stylesScopedClasses = (0, computeds_1.computedSet)(() => {
+        const classes = new Set();
+        if (!shouldGenerateScopedClasses()) {
+            return classes;
+        }
+        for (const style of _sfc.styles) {
+            const option = ctx.vueCompilerOptions.experimentalResolveStyleCssClasses;
+            if (option === 'always' || (option === 'scoped' && style.scoped)) {
+                for (const className of style.classNames) {
+                    classes.add(className.text.substring(1));
+                }
+            }
+        }
+        return classes;
+    });
+    const generatedTemplate = (0, computeds_1.computed)(() => {
+        if (!_sfc.template)
+            return;
+        const tsCodes = [];
+        const tsFormatCodes = [];
+        const inlineCssCodes = [];
+        const tsCodegenStacks = [];
+        const tsFormatCodegenStacks = [];
+        const inlineCssCodegenStacks = [];
+        const codegen = (0, template_1.generate)(ts, ctx.compilerOptions, ctx.vueCompilerOptions, _sfc.template, shouldGenerateScopedClasses(), stylesScopedClasses(), hasScriptSetupSlots(), slotsAssignName(), propsAssignName(), ctx.codegenStack);
+        let current = codegen.next();
+        while (!current.done) {
+            const [type, code, stack] = current.value;
+            if (type === 'ts') {
+                tsCodes.push(code);
+            }
+            else if (type === 'tsFormat') {
+                tsFormatCodes.push(code);
+            }
+            else if (type === 'inlineCss') {
+                inlineCssCodes.push(code);
+            }
+            if (ctx.codegenStack) {
+                if (type === 'ts') {
+                    tsCodegenStacks.push(stack);
+                }
+                else if (type === 'tsFormat') {
+                    tsFormatCodegenStacks.push(stack);
+                }
+                else if (type === 'inlineCss') {
+                    inlineCssCodegenStacks.push(stack);
+                }
+            }
+            current = codegen.next();
+        }
+        return {
+            ...current.value,
+            codes: tsCodes,
+            codeStacks: tsCodegenStacks,
+            formatCodes: tsFormatCodes,
+            formatCodeStacks: tsFormatCodegenStacks,
+            cssCodes: inlineCssCodes,
+            cssCodeStacks: inlineCssCodegenStacks,
+        };
+    });
+    const hasScriptSetupSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
+    const slotsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.slots.name);
+    const propsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.props.name);
+    const generatedScript = (0, computeds_1.computed)(() => {
+        const codes = [];
+        const codeStacks = [];
+        const linkedCodeMappings = [];
+        const _template = generatedTemplate();
+        let generatedLength = 0;
+        for (const [code, stack] of (0, script_1.generate)(ts, fileName, _sfc.script, _sfc.scriptSetup, _sfc.styles, lang(), scriptRanges(), scriptSetupRanges(), _template ? {
+            tsCodes: _template.codes,
+            tsCodegenStacks: _template.codeStacks,
+            accessedGlobalVariables: _template.accessedGlobalVariables,
+            hasSlot: _template.hasSlot,
+            tagNames: new Set(_template.tagOffsetsMap.keys()),
+        } : undefined, ctx.compilerOptions, ctx.vueCompilerOptions, ctx.globalTypesHolder, () => generatedLength, linkedCodeMappings, ctx.codegenStack)) {
+            codes.push(code);
+            if (ctx.codegenStack) {
+                codeStacks.push({ stack, length: 1 });
+            }
+            generatedLength += typeof code === 'string'
+                ? code.length
+                : code[0].length;
+        }
+        ;
+        return {
+            codes,
+            codeStacks,
+            linkedCodeMappings,
+        };
+    });
+    return {
+        scriptRanges,
+        scriptSetupRanges,
+        lang,
+        generatedScript,
+        generatedTemplate,
+    };
+}
+//# sourceMappingURL=vue-tsx.js.map

package/{out → lib}/plugins.d.ts

@@ -1,8 +1,18 @@
-import type * as ts from 'typescript/lib/tsserverlibrary';
-import { VueCompilerOptions } from './types';
 import * as CompilerDOM from '@vue/compiler-dom';
-export declare function getDefaultVueLanguagePlugins(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack: boolean): {
-    version: 1;
+import type * as ts from 'typescript';
+import { type VueCompilerOptions, type VueLanguagePlugin } from './types';
+export declare function createPluginContext(ts: typeof import('typescript'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack: boolean, globalTypesHolder: string | undefined): {
+    modules: {
+        typescript: typeof import("typescript");
+        '@vue/compiler-dom': typeof CompilerDOM;
+    };
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    codegenStack: boolean;
+    globalTypesHolder: string | undefined;
+};
+export declare function getDefaultVueLanguagePlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): {
+    version: 2;
     name?: string | undefined;
     order?: number | undefined;
     requiredCompilerOptions?: string[] | undefined;
@@ -19,7 +29,9 @@ export declare function getDefaultVueLanguagePlugins(ts: typeof import('typescri
         end: number;
         newText: string;
     }): CompilerDOM.CodegenResult | undefined;
-    getEmbeddedFileNames?(fileName: string, sfc: import("./types").Sfc): string[];
-    resolveEmbeddedFile?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./virtualFile/embeddedFile").VueEmbeddedFile): void;
+    getEmbeddedCodes?(fileName: string, sfc: import("./types").Sfc): {
+        id: string;
+        lang: string;
+    }[];
+    resolveEmbeddedCode?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./virtualFile/embeddedFile").VueEmbeddedCode): void;
 }[];
-//# sourceMappingURL=plugins.d.ts.map

package/{out → lib}/plugins.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultVueLanguagePlugins = void 0;
+exports.getDefaultVueLanguagePlugins = exports.createPluginContext = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
 const file_html_1 = require("./plugins/file-html");
 const file_md_1 = require("./plugins/file-md");
 const file_vue_1 = require("./plugins/file-vue");
@@ -10,21 +11,9 @@ const vue_sfc_styles_1 = require("./plugins/vue-sfc-styles");
 const vue_sfc_template_1 = require("./plugins/vue-sfc-template");
 const vue_template_html_1 = require("./plugins/vue-template-html");
 const vue_tsx_1 = require("./plugins/vue-tsx");
-const CompilerDOM = require("@vue/compiler-dom");
+const types_1 = require("./types");
 const CompilerVue2 = require("./utils/vue2TemplateCompiler");
-function getDefaultVueLanguagePlugins(ts, compilerOptions, vueCompilerOptions, codegenStack) {
-    const plugins = [
-        file_md_1.default,
-        file_html_1.default,
-        file_vue_1.default,
-        vue_template_html_1.default,
-        vue_sfc_styles_1.default,
-        vue_sfc_customblocks_1.default,
-        vue_sfc_scripts_1.default,
-        vue_sfc_template_1.default,
-        vue_tsx_1.default,
-        ...vueCompilerOptions.plugins,
-    ];
+function createPluginContext(ts, compilerOptions, vueCompilerOptions, codegenStack, globalTypesHolder) {
     const pluginCtx = {
         modules: {
             '@vue/compiler-dom': vueCompilerOptions.target < 3
@@ -38,18 +27,35 @@ function getDefaultVueLanguagePlugins(ts, compilerOptions, vueCompilerOptions, c
         compilerOptions,
         vueCompilerOptions,
         codegenStack,
+        globalTypesHolder,
     };
+    return pluginCtx;
+}
+exports.createPluginContext = createPluginContext;
+function getDefaultVueLanguagePlugins(pluginContext) {
+    const plugins = [
+        file_md_1.default, // .md for VitePress
+        file_html_1.default, // .html for PetiteVue
+        file_vue_1.default, // .vue and others for Vue
+        vue_template_html_1.default,
+        vue_sfc_styles_1.default,
+        vue_sfc_customblocks_1.default,
+        vue_sfc_scripts_1.default,
+        vue_sfc_template_1.default,
+        vue_tsx_1.default,
+        ...pluginContext.vueCompilerOptions.plugins,
+    ];
     const pluginInstances = plugins
-        .map(plugin => plugin(pluginCtx))
+        .map(plugin => plugin(pluginContext))
         .sort((a, b) => {
         const aOrder = a.order ?? 0;
         const bOrder = b.order ?? 0;
         return aOrder - bOrder;
     });
     return pluginInstances.filter((plugin) => {
-        const valid = plugin.version >= 1 && plugin.version < 2;
+        const valid = plugin.version === types_1.pluginVersion;
         if (!valid) {
-            console.warn(`Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected 1.x but got ${JSON.stringify(plugin.version)}`);
+            console.warn(`Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected ${JSON.stringify(types_1.pluginVersion)} but got ${JSON.stringify(plugin.version)}`);
         }
         return valid;
     });