@vue/language-core 2.1.8 → 2.2.0

package/lib/codegen/script/src.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSrc = generateSrc;
-const common_1 = require("../common");
+const utils_1 = require("../utils");
 const index_1 = require("./index");
 function* generateSrc(script, src) {
     if (src.endsWith('.d.ts')) {
-        src = src.substring(0, src.length - '.d.ts'.length);
+        src = src.slice(0, -'.d.ts'.length);
     }
     else if (src.endsWith('.ts')) {
-        src = src.substring(0, src.length - '.ts'.length);
+        src = src.slice(0, -'.ts'.length);
     }
     else if (src.endsWith('.tsx')) {
-        src = src.substring(0, src.length - '.tsx'.length) + '.jsx';
+        src = src.slice(0, -'.tsx'.length) + '.jsx';
     }
     if (!src.endsWith('.js') && !src.endsWith('.jsx')) {
         src = src + '.js';
@@ -45,7 +45,7 @@ function* generateSrc(script, src) {
                 },
         },
     ];
-    yield common_1.endOfLine;
-    yield `export { default } from '${src}'${common_1.endOfLine}`;
+    yield utils_1.endOfLine;
+    yield `export { default } from '${src}'${utils_1.endOfLine}`;
 }
 //# sourceMappingURL=src.js.map

package/lib/codegen/script/styleModulesType.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleModulesType = generateStyleModulesType;
+const utils_1 = require("../utils");
 const index_1 = require("./index");
 const template_1 = require("./template");
-const common_1 = require("../common");
 function* generateStyleModulesType(options, ctx) {
     const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
-    if (!styles.length) {
+    if (!styles.length && !options.scriptSetupRanges?.useCssModule.length) {
         return;
     }
-    yield `type __VLS_StyleModules = {${common_1.newLine}`;
+    yield `type __VLS_StyleModules = {${utils_1.newLine}`;
     for (const [style, i] of styles) {
         const { name, offset } = style.module;
         if (offset) {
@@ -27,8 +27,8 @@ function* generateStyleModulesType(options, ctx) {
         for (const className of style.classNames) {
             yield* (0, template_1.generateCssClassProperty)(i, className.text, className.offset, 'string', false);
         }
-        yield `>${common_1.endOfLine}`;
+        yield `>${utils_1.endOfLine}`;
     }
-    yield `}${common_1.endOfLine}`;
+    yield `}${utils_1.endOfLine}`;
 }
 //# sourceMappingURL=styleModulesType.js.map

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

@@ -2,7 +2,7 @@ import type { Code } from '../../types';
 import { TemplateCodegenContext } from '../template/context';
 import type { ScriptCodegenContext } from './context';
 import { type ScriptCodegenOptions } from './index';
-export declare function generateTemplateDirectives(options: ScriptCodegenOptions): Generator<Code>;
 export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code, TemplateCodegenContext>;
+export declare function generateTemplateDirectives(options: ScriptCodegenOptions): Generator<Code>;
 export declare function generateCssClassProperty(styleIndex: number, classNameWithDot: string, offset: number, propertyType: string, optional: boolean): Generator<Code>;
 export declare function getTemplateUsageVars(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Set<string>;

package/lib/codegen/script/template.js

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTemplateDirectives = generateTemplateDirectives;
 exports.generateTemplate = generateTemplate;
+exports.generateTemplateDirectives = generateTemplateDirectives;
 exports.generateCssClassProperty = generateCssClassProperty;
 exports.getTemplateUsageVars = getTemplateUsageVars;
+const path = require("path-browserify");
 const shared_1 = require("../../utils/shared");
-const common_1 = require("../common");
 const context_1 = require("../template/context");
 const interpolation_1 = require("../template/interpolation");
 const styleScopedClasses_1 = require("../template/styleScopedClasses");
+const utils_1 = require("../utils");
 const index_1 = require("./index");
+function* generateTemplate(options, ctx) {
+    ctx.generatedTemplate = true;
+    const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
+        scriptSetupBindingNames: new Set(),
+        edited: options.edited,
+    });
+    yield* generateTemplateCtx(options);
+    yield* generateTemplateComponents(options);
+    yield* generateTemplateDirectives(options);
+    yield* generateTemplateBody(options, templateCodegenCtx);
+    return templateCodegenCtx;
+}
 function* generateTemplateCtx(options) {
     const exps = [];
     exps.push(`{} as InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>`);
-    if (options.vueCompilerOptions.petiteVueExtensions.some(ext => options.fileBaseName.endsWith(ext))) {
+    if (options.vueCompilerOptions.petiteVueExtensions.some(ext => options.fileName.endsWith(ext))) {
         exps.push(`globalThis`);
     }
     if (options.sfc.styles.some(style => style.module)) {
@@ -22,100 +35,113 @@ function* generateTemplateCtx(options) {
     yield `const __VLS_ctx = `;
     if (exps.length === 1) {
         yield exps[0];
-        yield `${common_1.endOfLine}`;
+        yield `${utils_1.endOfLine}`;
     }
     else {
-        yield `{${common_1.newLine}`;
+        yield `{${utils_1.newLine}`;
         for (const exp of exps) {
             yield `...`;
             yield exp;
-            yield `,${common_1.newLine}`;
+            yield `,${utils_1.newLine}`;
         }
-        yield `}${common_1.endOfLine}`;
+        yield `}${utils_1.endOfLine}`;
     }
 }
 function* generateTemplateComponents(options) {
-    const exps = [];
+    const types = [];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
         const { componentsOption } = options.scriptRanges.exportDefault;
-        exps.push([
-            options.sfc.script.content.substring(componentsOption.start, componentsOption.end),
+        yield `const __VLS_componentsOption = `;
+        yield [
+            options.sfc.script.content.slice(componentsOption.start, componentsOption.end),
             'script',
             componentsOption.start,
             index_1.codeFeatures.navigation,
-        ]);
+        ];
+        yield utils_1.endOfLine;
+        types.push(`typeof __VLS_componentsOption`);
     }
     let nameType;
     if (options.sfc.script && options.scriptRanges?.exportDefault?.nameOption) {
         const { nameOption } = options.scriptRanges.exportDefault;
-        nameType = options.sfc.script.content.substring(nameOption.start, nameOption.end);
+        nameType = options.sfc.script.content.slice(nameOption.start, nameOption.end);
     }
     else if (options.sfc.scriptSetup) {
-        nameType = `'${options.scriptSetupRanges?.options.name ?? options.fileBaseName.substring(0, options.fileBaseName.lastIndexOf('.'))}'`;
+        const baseName = path.basename(options.fileName);
+        nameType = `'${options.scriptSetupRanges?.defineOptions?.name ?? baseName.slice(0, baseName.lastIndexOf('.'))}'`;
     }
     if (nameType) {
-        exps.push(`{} as {
-			[K in ${nameType}]: typeof __VLS_self
-				& (new () => {
-					${(0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)}: typeof ${options.scriptSetupRanges?.slots?.name ?? '__VLS_slots'}
-				})
-		}`);
-    }
-    exps.push(`{} as NonNullable<typeof __VLS_self extends { components: infer C } ? C : {}>`);
-    exps.push(`__VLS_ctx`);
-    yield `const __VLS_localComponents = {${common_1.newLine}`;
-    for (const type of exps) {
-        yield `...`;
+        types.push(`{ [K in ${nameType}]: typeof __VLS_self & (new () => { `
+            + (0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)
+            + `: typeof ${options.scriptSetupRanges?.defineSlots?.name ?? `__VLS_slots`} }) }`);
+    }
+    types.push(`typeof __VLS_ctx`);
+    yield `type __VLS_LocalComponents =`;
+    for (const type of types) {
+        yield ` & `;
         yield type;
-        yield `,${common_1.newLine}`;
     }
-    yield `}${common_1.endOfLine}`;
-    yield `let __VLS_components!: typeof __VLS_localComponents & __VLS_GlobalComponents${common_1.endOfLine}`;
+    yield utils_1.endOfLine;
+    yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
 }
 function* generateTemplateDirectives(options) {
-    const exps = [];
+    const types = [];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.directivesOption) {
         const { directivesOption } = options.scriptRanges.exportDefault;
-        exps.push([
-            options.sfc.script.content.substring(directivesOption.start, directivesOption.end),
+        yield `const __VLS_directivesOption = `;
+        yield [
+            options.sfc.script.content.slice(directivesOption.start, directivesOption.end),
             'script',
             directivesOption.start,
             index_1.codeFeatures.navigation,
-        ]);
-    }
-    exps.push(`{} as NonNullable<typeof __VLS_self extends { directives: infer D } ? D : {}>`);
-    exps.push(`__VLS_ctx`);
-    yield `const __VLS_localDirectives = {${common_1.newLine}`;
-    for (const type of exps) {
-        yield `...`;
+        ];
+        yield utils_1.endOfLine;
+        types.push(`typeof __VLS_directivesOption`);
+    }
+    types.push(`typeof __VLS_ctx`);
+    yield `type __VLS_LocalDirectives =`;
+    for (const type of types) {
+        yield ` & `;
         yield type;
-        yield `,${common_1.newLine}`;
     }
-    yield `}${common_1.endOfLine}`;
-    yield `let __VLS_directives!: typeof __VLS_localDirectives & __VLS_GlobalDirectives${common_1.endOfLine}`;
-}
-function* generateTemplate(options, ctx) {
-    ctx.generatedTemplate = true;
-    const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
-        scriptSetupBindingNames: new Set(),
-        edited: options.edited,
-    });
-    yield* generateTemplateCtx(options);
-    yield* generateTemplateComponents(options);
-    yield* generateTemplateDirectives(options);
-    yield* generateTemplateBody(options, templateCodegenCtx);
-    return templateCodegenCtx;
+    yield utils_1.endOfLine;
+    yield `let __VLS_directives!: __VLS_LocalDirectives & __VLS_GlobalDirectives${utils_1.endOfLine}`;
 }
 function* generateTemplateBody(options, templateCodegenCtx) {
+    yield* generateStyleScopedClasses(options, templateCodegenCtx);
+    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(templateCodegenCtx, true);
+    yield* generateCssVars(options, templateCodegenCtx);
+    if (options.templateCodegen) {
+        for (const code of options.templateCodegen.codes) {
+            yield code;
+        }
+    }
+    else {
+        yield `// no template${utils_1.newLine}`;
+        if (!options.scriptSetupRanges?.defineSlots) {
+            yield `const __VLS_slots = {}${utils_1.endOfLine}`;
+        }
+        yield `const __VLS_inheritedAttrs = {}${utils_1.endOfLine}`;
+        yield `const $refs = {}${utils_1.endOfLine}`;
+        yield `const $el = {} as any${utils_1.endOfLine}`;
+    }
+    yield `return {${utils_1.newLine}`;
+    yield `	attrs: {} as Partial<typeof __VLS_inheritedAttrs>,${utils_1.newLine}`;
+    yield `	slots: ${options.scriptSetupRanges?.defineSlots?.name ?? '__VLS_slots'},${utils_1.newLine}`;
+    yield `	refs: $refs,${utils_1.newLine}`;
+    yield `	rootEl: $el,${utils_1.newLine}`;
+    yield `}${utils_1.endOfLine}`;
+}
+function* generateStyleScopedClasses(options, ctx) {
     const firstClasses = new Set();
-    yield `let __VLS_styleScopedClasses!: {}`;
+    yield `type __VLS_StyleScopedClasses = {}`;
     for (let i = 0; i < options.sfc.styles.length; i++) {
         const style = options.sfc.styles[i];
         const option = options.vueCompilerOptions.experimentalResolveStyleCssClasses;
         if (option === 'always' || (option === 'scoped' && style.scoped)) {
             for (const className of style.classNames) {
                 if (firstClasses.has(className.text)) {
-                    templateCodegenCtx.scopedClasses.push({
+                    ctx.scopedClasses.push({
                         source: 'style_' + i,
                         className: className.text.slice(1),
                         offset: className.offset + 1
@@ -127,32 +153,10 @@ function* generateTemplateBody(options, templateCodegenCtx) {
             }
         }
     }
-    yield common_1.endOfLine;
-    yield* (0, styleScopedClasses_1.generateStyleScopedClasses)(templateCodegenCtx, true);
-    yield* generateCssVars(options, templateCodegenCtx);
-    if (options.templateCodegen) {
-        for (const code of options.templateCodegen.codes) {
-            yield code;
-        }
-    }
-    else {
-        yield `// no template${common_1.newLine}`;
-        if (!options.scriptSetupRanges?.slots.define) {
-            yield `const __VLS_slots = {}${common_1.endOfLine}`;
-        }
-        yield `const __VLS_inheritedAttrs = {}${common_1.endOfLine}`;
-        yield `const $refs = {}${common_1.endOfLine}`;
-        yield `const $el = {} as any${common_1.endOfLine}`;
-    }
-    yield `return {${common_1.newLine}`;
-    yield `	attrs: {} as Partial<typeof __VLS_inheritedAttrs>,${common_1.newLine}`;
-    yield `	slots: ${options.scriptSetupRanges?.slots.name ?? '__VLS_slots'},${common_1.newLine}`;
-    yield `	refs: $refs,${common_1.newLine}`;
-    yield `	rootEl: $el,${common_1.newLine}`;
-    yield `}${common_1.endOfLine}`;
+    yield utils_1.endOfLine;
 }
 function* generateCssClassProperty(styleIndex, classNameWithDot, offset, propertyType, optional) {
-    yield `${common_1.newLine} & { `;
+    yield `${utils_1.newLine} & { `;
     yield [
         '',
         'style_' + styleIndex,
@@ -161,7 +165,7 @@ function* generateCssClassProperty(styleIndex, classNameWithDot, offset, propert
     ];
     yield `'`;
     yield [
-        classNameWithDot.substring(1),
+        classNameWithDot.slice(1),
         'style_' + styleIndex,
         offset + 1,
         index_1.codeFeatures.navigation,
@@ -180,28 +184,14 @@ function* generateCssVars(options, ctx) {
     if (!options.sfc.styles.length) {
         return;
     }
-    yield `// CSS variable injection ${common_1.newLine}`;
+    yield `// CSS variable injection ${utils_1.newLine}`;
     for (const style of options.sfc.styles) {
         for (const cssBind of style.cssVars) {
-            for (const [segment, offset, onlyError] of (0, interpolation_1.forEachInterpolationSegment)(options.ts, undefined, undefined, ctx, cssBind.text, cssBind.offset, options.ts.createSourceFile('/a.txt', cssBind.text, 99))) {
-                if (offset === undefined) {
-                    yield segment;
-                }
-                else {
-                    yield [
-                        segment,
-                        style.name,
-                        cssBind.offset + offset,
-                        onlyError
-                            ? index_1.codeFeatures.navigation
-                            : index_1.codeFeatures.all,
-                    ];
-                }
-            }
-            yield common_1.endOfLine;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, style.name, index_1.codeFeatures.all, cssBind.text, cssBind.offset);
+            yield utils_1.endOfLine;
         }
     }
-    yield `// CSS variable injection end ${common_1.newLine}`;
+    yield `// CSS variable injection end ${utils_1.newLine}`;
 }
 function getTemplateUsageVars(options, ctx) {
     const usageVars = new Set();
@@ -214,7 +204,7 @@ function getTemplateUsageVars(options, ctx) {
             }
         }
         for (const component of components) {
-            if (component.indexOf('.') >= 0) {
+            if (component.includes('.')) {
                 usageVars.add(component.split('.')[0]);
             }
         }

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

@@ -1,7 +1,7 @@
 import type * as CompilerDOM from '@vue/compiler-dom';
 import type { Code, VueCodeInformation } from '../../types';
-import type { TemplateCodegenOptions } from './index';
 import { InlayHintInfo } from '../inlayHints';
+import type { TemplateCodegenOptions } from './index';
 export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
 export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames' | 'edited'>): {
     slots: {
@@ -24,14 +24,18 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
         navigationWithoutRename: VueCodeInformation;
         navigationAndCompletion: VueCodeInformation;
         navigationAndAdditionalCompletion: VueCodeInformation;
+        withoutNavigation: VueCodeInformation;
         withoutHighlight: VueCodeInformation;
         withoutHighlightAndCompletion: VueCodeInformation;
         withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
     };
     accessExternalVariables: Map<string, Set<number>>;
+    lastGenericComment: {
+        content: string;
+        offset: number;
+    } | undefined;
     hasSlotElements: Set<CompilerDOM.ElementNode>;
     blockConditions: string[];
-    usedComponentCtxVars: Set<string>;
     scopedClasses: {
         source: string;
         className: string;
@@ -40,8 +44,14 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     emptyClassOffsets: number[];
     inlayHints: InlayHintInfo[];
     hasSlot: boolean;
-    inheritedAttrVars: Set<unknown>;
+    bindingAttrLocs: CompilerDOM.SourceLocation[];
+    inheritedAttrVars: Set<string>;
     templateRefs: Map<string, [varName: string, offset: number]>;
+    currentComponent: {
+        node: CompilerDOM.ElementNode;
+        ctxVar: string;
+        used: boolean;
+    } | undefined;
     singleRootElType: string | undefined;
     singleRootNode: CompilerDOM.ElementNode | undefined;
     accessExternalVariable(name: string, offset?: number): void;

package/lib/codegen/template/context.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTemplateCodegenContext = createTemplateCodegenContext;
-const common_1 = require("../common");
+const utils_1 = require("../utils");
 const _codeFeatures = {
     all: {
         verification: true,
@@ -36,6 +36,11 @@ const _codeFeatures = {
         navigation: true,
         completion: { isAdditional: true },
     },
+    withoutNavigation: {
+        verification: true,
+        completion: true,
+        semantic: true,
+    },
     withoutHighlight: {
         semantic: { shouldHighlight: () => false },
         verification: true,
@@ -55,6 +60,7 @@ const _codeFeatures = {
 function createTemplateCodegenContext(options) {
     let ignoredError = false;
     let expectErrorToken;
+    let lastGenericComment;
     let variableId = 0;
     const codeFeatures = new Proxy(_codeFeatures, {
         get(target, key) {
@@ -91,25 +97,28 @@ function createTemplateCodegenContext(options) {
     const hasSlotElements = new Set();
     ;
     const blockConditions = [];
-    const usedComponentCtxVars = new Set();
     const scopedClasses = [];
     const emptyClassOffsets = [];
     const inlayHints = [];
+    const bindingAttrLocs = [];
+    const inheritedAttrVars = new Set();
     const templateRefs = new Map();
     return {
         slots,
         dynamicSlots,
         codeFeatures,
         accessExternalVariables,
+        lastGenericComment,
         hasSlotElements,
         blockConditions,
-        usedComponentCtxVars,
         scopedClasses,
         emptyClassOffsets,
         inlayHints,
         hasSlot: false,
-        inheritedAttrVars: new Set(),
+        bindingAttrLocs,
+        inheritedAttrVars,
         templateRefs,
+        currentComponent: undefined,
         singleRootElType: undefined,
         singleRootNode: undefined,
         accessExternalVariable(name, offset) {
@@ -136,7 +145,7 @@ function createTemplateCodegenContext(options) {
         ignoreError: function* () {
             if (!ignoredError) {
                 ignoredError = true;
-                yield `// @vue-ignore start${common_1.newLine}`;
+                yield `// @vue-ignore start${utils_1.newLine}`;
             }
         },
         expectError: function* (prevNode) {
@@ -145,24 +154,24 @@ function createTemplateCodegenContext(options) {
                     errors: 0,
                     node: prevNode,
                 };
-                yield `// @vue-expect-error start${common_1.newLine}`;
+                yield `// @vue-expect-error start${utils_1.newLine}`;
             }
         },
         resetDirectiveComments: function* (endStr) {
             if (expectErrorToken) {
                 const token = expectErrorToken;
-                yield* (0, common_1.wrapWith)(expectErrorToken.node.loc.start.offset, expectErrorToken.node.loc.end.offset, {
+                yield* (0, utils_1.wrapWith)(expectErrorToken.node.loc.start.offset, expectErrorToken.node.loc.end.offset, {
                     verification: {
                         shouldReport: () => token.errors === 0,
                     },
                 }, `// @ts-expect-error __VLS_TS_EXPECT_ERROR`);
-                yield `${common_1.newLine}${common_1.endOfLine}`;
+                yield `${utils_1.newLine}${utils_1.endOfLine}`;
                 expectErrorToken = undefined;
-                yield `// @vue-expect-error ${endStr}${common_1.newLine}`;
+                yield `// @vue-expect-error ${endStr}${utils_1.newLine}`;
             }
             if (ignoredError) {
                 ignoredError = false;
-                yield `// @vue-ignore ${endStr}${common_1.newLine}`;
+                yield `// @vue-ignore ${endStr}${utils_1.newLine}`;
             }
         },
         generateAutoImportCompletion: function* () {
@@ -173,7 +182,7 @@ function createTemplateCodegenContext(options) {
             if (!all.some(([_, offsets]) => offsets.size)) {
                 return;
             }
-            yield `// @ts-ignore${common_1.newLine}`; // #2304
+            yield `// @ts-ignore${utils_1.newLine}`; // #2304
             yield `[`;
             for (const [varName, offsets] of all) {
                 for (const offset of offsets) {
@@ -201,7 +210,7 @@ function createTemplateCodegenContext(options) {
                 }
                 offsets.clear();
             }
-            yield `]${common_1.endOfLine}`;
+            yield `]${utils_1.endOfLine}`;
         }
     };
 }

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

@@ -2,7 +2,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 generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentComponent: CompilerDOM.ElementNode | undefined): Generator<Code>;
-export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined, isVForChild: boolean): Generator<Code>;
-export declare function getCanonicalComponentName(tagText: string): string;
-export declare function getPossibleOriginalComponentNames(tagText: string, deduplicate: boolean): string[];
+export declare function generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
+export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, isVForChild: boolean): Generator<Code>;