@vue/language-core 3.1.5 → 3.1.6

package/lib/codegen/utils/merge.js

@@ -3,22 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateIntersectMerge = generateIntersectMerge;
 exports.generateSpreadMerge = generateSpreadMerge;
 const index_1 = require("./index");
-function* generateIntersectMerge(codes) {
-    yield codes[0];
-    for (let i = 1; i < codes.length; i++) {
+function* generateIntersectMerge(generates) {
+    yield* generates[0];
+    for (let i = 1; i < generates.length; i++) {
         yield ` & `;
-        yield codes[i];
+        yield* generates[i];
     }
 }
-function* generateSpreadMerge(codes) {
-    if (codes.length === 1) {
-        yield codes[0];
+function* generateSpreadMerge(generates) {
+    if (generates.length === 1) {
+        yield* generates[0];
     }
     else {
         yield `{${index_1.newLine}`;
-        for (const code of codes) {
+        for (const generate of generates) {
             yield `...`;
-            yield code;
+            yield* generate;
             yield `,${index_1.newLine}`;
         }
         yield `}`;

package/lib/codegen/utils/stringLiteralKey.js

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

package/lib/codegen/utils/transform.d.ts

@@ -0,0 +1,8 @@
+import type { Code } from '../../types';
+export interface CodeTransform {
+    range: [start: number, end: number];
+    generate(): Iterable<Code>;
+}
+export declare function replace(start: number, end: number, replacement: () => Iterable<Code>): CodeTransform;
+export declare function insert(position: number, insertion: () => Iterable<Code>): CodeTransform;
+export declare function generateCodeWithTransforms(start: number, end: number, transforms: CodeTransform[], section: (start: number, end: number) => Iterable<Code>): Generator<Code>;

package/lib/codegen/utils/transform.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replace = replace;
+exports.insert = insert;
+exports.generateCodeWithTransforms = generateCodeWithTransforms;
+function replace(start, end, replacement) {
+    return {
+        range: [start, end],
+        generate: replacement,
+    };
+}
+function insert(position, insertion) {
+    return {
+        range: [position, position],
+        generate: insertion,
+    };
+}
+function* generateCodeWithTransforms(start, end, transforms, section) {
+    const sortedTransforms = transforms.sort((a, b) => a.range[0] - b.range[0]);
+    for (const { range, generate } of sortedTransforms) {
+        yield* section(start, range[0]);
+        yield* generate();
+        start = range[1];
+    }
+    yield* section(start, end);
+}
+//# sourceMappingURL=transform.js.map

package/lib/codegen/utils/unicode.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateUnicode = generateUnicode;
-const wrapWith_1 = require("./wrapWith");
+const boundary_1 = require("./boundary");
 function* generateUnicode(code, offset, info) {
     if (needToUnicode(code)) {
-        yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, info, toUnicode(code));
+        const token = yield* (0, boundary_1.startBoundary)('template', offset, info);
+        yield toUnicode(code);
+        yield (0, boundary_1.endBoundary)(token, offset + code.length);
     }
     else {
         yield [code, 'template', offset, info];

package/lib/compilerOptions.d.ts

@@ -1,10 +1,12 @@
 import type * as ts from 'typescript';
 import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from './types';
+interface ParseConfigHost extends Omit<ts.ParseConfigHost, 'readDirectory'> {
+}
 export interface ParsedCommandLine extends Omit<ts.ParsedCommandLine, 'fileNames'> {
     vueOptions: VueCompilerOptions;
 }
-export declare const createParsedCommandLineByJson: (ts: typeof import("typescript"), host: Omit<ts.ParseConfigHost, "readDirectory">, rootDir: string, json: any, configFileName?: string | undefined) => ParsedCommandLine;
-export declare const createParsedCommandLine: (ts: typeof import("typescript"), host: Omit<ts.ParseConfigHost, "readDirectory">, configFileName: string) => ParsedCommandLine;
+export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), host: ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
+export declare function createParsedCommandLine(ts: typeof import('typescript'), host: ParseConfigHost, configFileName: string): ParsedCommandLine;
 export declare class CompilerOptionsResolver {
     fileExists?: ((path: string) => boolean) | undefined;
     options: Omit<RawVueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>;
@@ -22,3 +24,4 @@ export declare function createGlobalTypesWriter(vueOptions: VueCompilerOptions,
  * @deprecated use `createGlobalTypesWriter` instead
  */
 export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;
+export {};

package/lib/compilerOptions.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompilerOptionsResolver = exports.createParsedCommandLine = exports.createParsedCommandLineByJson = void 0;
+exports.CompilerOptionsResolver = void 0;
+exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
+exports.createParsedCommandLine = createParsedCommandLine;
 exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
 exports.createGlobalTypesWriter = createGlobalTypesWriter;
 exports.writeGlobalTypes = writeGlobalTypes;
@@ -8,54 +10,75 @@ const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
 const globalTypes_1 = require("./codegen/globalTypes");
 const shared_2 = require("./utils/shared");
-exports.createParsedCommandLineByJson = create((ts, host, rootDir, json, configFileName) => {
-    // `parseJsonConfigFileContent` is missing in tsc
-    return 'parseJsonConfigFileContent' in ts
-        ? ts.parseJsonConfigFileContent(json, host, rootDir, {}, configFileName)
-        : ts.parseJsonSourceFileConfigFileContent(ts.parseJsonText(configFileName ?? 'tsconfig.json', JSON.stringify(json)), host, rootDir, {}, configFileName);
-});
-exports.createParsedCommandLine = create((ts, host, configFileName) => {
-    const config = ts.readJsonConfigFile(configFileName, host.readFile);
-    return ts.parseJsonSourceFileConfigFileContent(config, host, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
-});
-function create(getParsedCommandLine) {
-    return (ts, host, ...args) => {
+function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName) {
+    const extendedPaths = new Set();
+    const proxyHost = {
+        ...host,
+        readFile(fileName) {
+            if (!fileName.endsWith('/package.json')) {
+                extendedPaths.add(fileName);
+            }
+            return host.readFile(fileName);
+        },
+        readDirectory() {
+            return [];
+        },
+    };
+    const config = ts.readJsonConfigFile(rootDir, () => JSON.stringify(json));
+    const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, rootDir, {}, configFileName);
+    const resolver = new CompilerOptionsResolver(host.fileExists);
+    for (const extendPath of [...extendedPaths].reverse()) {
         try {
-            const extendedPaths = new Set();
-            const proxyHost = {
-                ...host,
-                readFile(fileName) {
-                    if (!fileName.endsWith('/package.json')) {
-                        extendedPaths.add(fileName);
-                    }
-                    return host.readFile(fileName);
-                },
-                readDirectory() {
-                    return [];
-                },
-            };
-            const parsed = getParsedCommandLine(ts, proxyHost, ...args);
-            const resolver = new CompilerOptionsResolver(host.fileExists);
-            for (const extendPath of [...extendedPaths].reverse()) {
-                try {
-                    const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
-                    const obj = ts.convertToObject(configFile, []);
-                    const rawOptions = obj?.vueCompilerOptions ?? {};
-                    resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
+            const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
+            const obj = ts.convertToObject(configFile, []);
+            const rawOptions = obj?.vueCompilerOptions ?? {};
+            resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
+        }
+        catch { }
+    }
+    resolver.addConfig(json?.vueCompilerOptions ?? {}, rootDir);
+    return {
+        ...parsed,
+        vueOptions: resolver.build(),
+    };
+}
+function createParsedCommandLine(ts, host, configFileName) {
+    try {
+        const extendedPaths = new Set();
+        const proxyHost = {
+            ...host,
+            readFile(fileName) {
+                if (!fileName.endsWith('/package.json')) {
+                    extendedPaths.add(fileName);
                 }
-                catch { }
+                return host.readFile(fileName);
+            },
+            readDirectory() {
+                return [];
+            },
+        };
+        const config = ts.readJsonConfigFile(configFileName, proxyHost.readFile);
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
+        const resolver = new CompilerOptionsResolver(host.fileExists);
+        for (const extendPath of [...extendedPaths].reverse()) {
+            try {
+                const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
+                const obj = ts.convertToObject(configFile, []);
+                const rawOptions = obj?.vueCompilerOptions ?? {};
+                resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
             }
-            return {
-                ...parsed,
-                vueOptions: resolver.build(),
-            };
+            catch { }
         }
-        catch { }
         return {
-            options: {},
-            errors: [],
-            vueOptions: getDefaultCompilerOptions(),
+            ...parsed,
+            vueOptions: resolver.build(),
         };
+    }
+    catch { }
+    return {
+        options: {},
+        errors: [],
+        vueOptions: getDefaultCompilerOptions(),
     };
 }
 class CompilerOptionsResolver {
@@ -128,7 +151,7 @@ class CompilerOptionsResolver {
                 ...defaults.fallthroughComponentNames,
                 ...this.options.fallthroughComponentNames ?? [],
             ].map(shared_2.hyphenateTag),
-            // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
+            // https://github.com/vuejs/core/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
             // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
             experimentalModelPropName: Object.fromEntries(Object.entries(this.options.experimentalModelPropName ?? defaults.experimentalModelPropName).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
         };

package/lib/languagePlugin.d.ts

@@ -1,6 +1,6 @@
 import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions } from './types';
-import { VueVirtualCode } from './virtualFile/vueFile';
+import { VueVirtualCode } from './virtualCode';
 export declare function createVueLanguagePlugin<T>(ts: typeof import('typescript'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, asFileName: (scriptId: T) => string): LanguagePlugin<T, VueVirtualCode>;
 export declare function getAllExtensions(options: VueCompilerOptions): string[];

package/lib/languagePlugin.js

@@ -6,7 +6,7 @@ exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const plugins_1 = require("./plugins");
-const vueFile_1 = require("./virtualFile/vueFile");
+const virtualCode_1 = require("./virtualCode");
 const fileRegistries = {};
 function getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins) {
     const key = JSON.stringify([
@@ -53,7 +53,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
                     return code;
                 }
                 else {
-                    const code = new vueFile_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
+                    const code = new virtualCode_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
                     fileRegistry.set(fileName, code);
                     return code;
                 }

package/lib/plugins/vue-template-inline-css.js

@@ -35,12 +35,8 @@ function* generate(templateAst) {
                 && prop.name === 'style'
                 && prop.value) {
                 yield `x { `;
-                yield [
-                    prop.value.content,
-                    'template',
-                    (0, shared_1.getAttributeValueOffset)(prop.value),
-                    codeFeatures,
-                ];
+                const [content, offset] = (0, shared_1.normalizeAttributeValue)(prop.value);
+                yield [content, 'template', offset, codeFeatures];
                 yield ` }\n`;
             }
         }

package/lib/plugins/vue-template-inline-ts.js

@@ -5,7 +5,6 @@ const elementEvents_1 = require("../codegen/template/elementEvents");
 const templateChild_1 = require("../codegen/template/templateChild");
 const vFor_1 = require("../codegen/template/vFor");
 const utils_1 = require("../codegen/utils");
-const computedSfc_1 = require("../virtualFile/computedSfc");
 const codeFeatures = {
     format: true,
 };
@@ -21,7 +20,7 @@ const formatBrackets = {
     event: ['() => ', ';'],
     generic: ['<', '>() => {};'],
 };
-const plugin = ctx => {
+const plugin = ({ modules: { typescript: ts } }) => {
     const parseds = new WeakMap();
     return {
         version: 2.2,
@@ -54,15 +53,14 @@ const plugin = ctx => {
         },
     };
     function parse(sfc) {
-        const data = new Map();
+        const result = new Map();
         if (!sfc.template?.ast) {
-            return data;
+            return result;
         }
-        const templateContent = sfc.template.content;
-        const inlineTsAsts = computedSfc_1.templateInlineTsAsts.get(sfc.template.ast);
+        const template = sfc.template;
         let i = 0;
         sfc.template.ast.children.forEach(visit);
-        return data;
+        return result;
         function visit(node) {
             if (node.type === CompilerDOM.NodeTypes.COMMENT) {
                 const match = node.loc.source.match(/^<!--\s*@vue-generic\s*\{(?<content>[\s\S]*)\}\s*-->$/);
@@ -87,8 +85,8 @@ const plugin = ctx => {
                         && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY // style='z-index: 2' will compile to {'z-index':'2'}
                     ) {
                         if (prop.name === 'on' && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                            const ast = (0, utils_1.createTsAst)(ctx.modules.typescript, inlineTsAsts, prop.exp.content);
-                            if ((0, elementEvents_1.isCompoundExpression)(ctx.modules.typescript, ast)) {
+                            const ast = (0, utils_1.getTypeScriptAST)(ts, template, prop.exp.content);
+                            if ((0, elementEvents_1.isCompoundExpression)(ts, ast)) {
                                 addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.event);
                             }
                             else {
@@ -135,13 +133,13 @@ const plugin = ctx => {
                 if (leftExpressionRange && leftExpressionText && source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                     let start = leftExpressionRange.start;
                     let end = source.loc.start.offset + source.content.length;
-                    while (templateContent[start - 1] === ' ' || templateContent[start - 1] === '(') {
+                    while (template.content[start - 1] === ' ' || template.content[start - 1] === '(') {
                         start--;
                     }
-                    while (templateContent[end] === ' ' || templateContent[end] === ')') {
+                    while (template.content[end] === ' ' || template.content[end] === ')') {
                         end++;
                     }
-                    addFormatCodes(templateContent.slice(start, end), start, formatBrackets.for);
+                    addFormatCodes(template.content.slice(start, end), start, formatBrackets.for);
                 }
                 for (const child of node.children) {
                     visit(child);
@@ -161,7 +159,7 @@ const plugin = ctx => {
             }
             else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
                 // {{ ... }}
-                const [content, start] = (0, templateChild_1.parseInterpolationNode)(node, templateContent);
+                const [content, start] = (0, templateChild_1.parseInterpolationNode)(node, template.content);
                 const lines = content.split('\n');
                 const firstLineEmpty = lines[0].trim() === '';
                 const lastLineEmpty = lines[lines.length - 1].trim() === '';
@@ -188,7 +186,7 @@ const plugin = ctx => {
         }
         function addFormatCodes(code, offset, wrapper) {
             const id = 'template_inline_ts_' + i++;
-            data.set(id, [
+            result.set(id, [
                 wrapper[0],
                 [
                     code,

package/lib/plugins/vue-tsx.d.ts

@@ -1,6 +1,5 @@
 import type { Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
-    getLang: () => string;
     getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
@@ -121,14 +120,11 @@ export declare const tsCodegen: WeakMap<Sfc, {
     getSetupSlotsAssignName: () => string | undefined;
     getGeneratedScript: () => {
         codes: import("../types").Code[];
-        generatedTemplate: boolean;
-        generatedPropsType: boolean;
-        bypassDefineComponent: boolean;
-        bindingNames: Set<string>;
+        generatedTypes: Set<string>;
         localTypes: {
             generate: () => Generator<string, void, unknown>;
             readonly PrettifyLocal: string;
-            readonly WithDefaultsLocal: string;
+            readonly WithDefaults: string;
             readonly WithSlots: string;
             readonly PropsChildren: string;
             readonly TypePropsToOption: string;
@@ -138,6 +134,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
     };
     getGeneratedTemplate: () => {
         codes: import("../types").Code[];
+        generatedTypes: Set<string>;
         currentInfo: {
             ignoreError?: boolean;
             expectError?: {
@@ -150,7 +147,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
             };
         };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
-        inlineTsAsts: Map<string, import("typescript").SourceFile> | undefined;
         inVFor: boolean;
         slots: {
             name: string;
@@ -164,16 +160,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
             propsVar: string;
         }[];
         dollarVars: Set<string>;
-        accessExternalVariables: Map<string, Set<number>>;
+        componentAccessMap: Map<string, Map<string, Set<number>>>;
         blockConditions: string[];
-        scopedClasses: {
-            source: string;
-            className: string;
-            offset: number;
-        }[];
-        emptyClassOffsets: number[];
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
-        bindingAttrLocs: import("@vue/compiler-dom").SourceLocation[];
         inheritedAttrVars: Set<string>;
         templateRefs: Map<string, {
             typeExp: string;
@@ -186,18 +175,20 @@ export declare const tsCodegen: WeakMap<Sfc, {
         singleRootElTypes: Set<string>;
         singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
         addTemplateRef(name: string, typeExp: string, offset: number): void;
-        accessExternalVariable(name: string, offset?: number): void;
-        hasLocalVariable(name: string): boolean;
-        addLocalVariable(name: string): void;
-        removeLocalVariable(name: string): void;
+        recordComponentAccess(source: string, name: string, offset?: number): void;
+        scopes: Set<string>[];
+        declare(...varNames: string[]): void;
+        startScope(): () => Generator<import("../types").Code, any, any>;
         getInternalVariable(): string;
         getHoistVariable(originalVar: string): string;
         generateHoistVariables(): Generator<string, void, unknown>;
         generateConditionGuards(): Generator<string, void, unknown>;
-        generateAutoImportCompletion(): Generator<import("../types").Code>;
         enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
         exit(): Generator<import("../types").Code>;
     } | undefined;
+    getImportComponentNames: () => Set<string>;
+    getSetupExposed: () => Set<string>;
+    getSetupConsts: () => Set<string>;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;