@vue/language-core 2.0.29 → 2.1.2

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

@@ -1,5 +1,8 @@
 import type { Code } from '../../types';
 import type { ScriptCodegenContext } from './context';
 import { type ScriptCodegenOptions } from './index';
+export declare function generateTemplateCtx(options: ScriptCodegenOptions, isClassComponent: boolean): Generator<Code>;
+export declare function generateTemplateComponents(options: ScriptCodegenOptions): Generator<Code>;
 export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, isClassComponent: boolean): 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,119 +1,114 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTemplateCtx = generateTemplateCtx;
+exports.generateTemplateComponents = generateTemplateComponents;
 exports.generateTemplate = generateTemplate;
+exports.generateCssClassProperty = generateCssClassProperty;
 exports.getTemplateUsageVars = getTemplateUsageVars;
 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 index_1 = require("./index");
 const internalComponent_1 = require("./internalComponent");
-function* generateTemplate(options, ctx, isClassComponent) {
-    ctx.generatedTemplate = true;
-    if (!options.vueCompilerOptions.skipTemplateCodegen) {
-        if (isClassComponent) {
-            yield `__VLS_template() {${common_1.newLine}`;
-        }
-        else {
-            yield `function __VLS_template() {${common_1.newLine}`;
-        }
-        const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)(new Set());
-        yield* generateCtx(options, ctx, isClassComponent);
-        yield* generateTemplateContext(options, templateCodegenCtx);
-        yield* generateExportOptions(options);
-        yield* generateConstNameOption(options);
-        yield* (0, internalComponent_1.generateInternalComponent)(options, ctx, templateCodegenCtx);
-        yield `}${common_1.newLine}`;
+function* generateTemplateCtx(options, isClassComponent) {
+    const types = [];
+    if (isClassComponent) {
+        types.push(`typeof this`);
     }
     else {
-        yield `function __VLS_template() {${common_1.newLine}`;
-        const templateUsageVars = [...getTemplateUsageVars(options, ctx)];
-        yield `// @ts-ignore${common_1.newLine}`;
-        yield `[${templateUsageVars.join(', ')}]${common_1.newLine}`;
-        yield `return {}${common_1.endOfLine}`;
-        yield `}${common_1.newLine}`;
+        types.push(`InstanceType<__VLS_PickNotAny<typeof __VLS_internalComponent, new () => {}>>`);
     }
+    if (options.vueCompilerOptions.petiteVueExtensions.some(ext => options.fileBaseName.endsWith(ext))) {
+        types.push(`typeof globalThis`);
+    }
+    if (options.sfc.styles.some(style => style.module)) {
+        types.push(`__VLS_StyleModules`);
+    }
+    yield `let __VLS_ctx!: ${types.join(' & ')}${common_1.endOfLine}`;
 }
-function* generateExportOptions(options) {
-    yield common_1.newLine;
-    yield `const __VLS_componentsOption = `;
+function* generateTemplateComponents(options) {
+    const exps = [];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
-        const componentsOption = options.scriptRanges.exportDefault.componentsOption;
-        yield [
+        const { componentsOption } = options.scriptRanges.exportDefault;
+        exps.push([
             options.sfc.script.content.substring(componentsOption.start, componentsOption.end),
             'script',
             componentsOption.start,
             index_1.codeFeatures.navigation,
-        ];
-    }
-    else {
-        yield `{}`;
+        ]);
     }
-    yield common_1.endOfLine;
-}
-function* generateConstNameOption(options) {
+    let nameType;
     if (options.sfc.script && options.scriptRanges?.exportDefault?.nameOption) {
-        const nameOption = options.scriptRanges.exportDefault.nameOption;
-        yield `const __VLS_name = `;
-        yield `${options.sfc.script.content.substring(nameOption.start, nameOption.end)} as const`;
-        yield common_1.endOfLine;
+        const { nameOption } = options.scriptRanges.exportDefault;
+        nameType = options.sfc.script.content.substring(nameOption.start, nameOption.end);
     }
     else if (options.sfc.scriptSetup) {
         yield `let __VLS_name!: '${options.scriptSetupRanges?.options.name ?? options.fileBaseName.substring(0, options.fileBaseName.lastIndexOf('.'))}'${common_1.endOfLine}`;
-    }
-    else {
-        yield `const __VLS_name = undefined${common_1.endOfLine}`;
-    }
+        nameType = 'typeof __VLS_name';
+    }
+    if (nameType) {
+        exps.push(`{} as {
+			[K in ${nameType}]: typeof __VLS_internalComponent
+				& (new () => {
+					${(0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)}: typeof ${options.scriptSetupRanges?.slots?.name ?? '__VLS_slots'}
+				})
+		}`);
+    }
+    exps.push(`{} as NonNullable<typeof __VLS_internalComponent extends { components: infer C } ? C : {}>`);
+    exps.push(`{} as __VLS_GlobalComponents`);
+    exps.push(`{} as typeof __VLS_ctx`);
+    yield `const __VLS_components = {${common_1.newLine}`;
+    for (const type of exps) {
+        yield `...`;
+        yield type;
+        yield `,${common_1.newLine}`;
+    }
+    yield `}${common_1.endOfLine}`;
 }
-function* generateCtx(options, ctx, isClassComponent) {
-    yield `let __VLS_ctx!: `;
-    if (options.vueCompilerOptions.petiteVueExtensions.some(ext => options.fileBaseName.endsWith(ext))) {
-        yield `typeof globalThis & `;
-    }
-    if (!isClassComponent) {
-        yield `InstanceType<__VLS_PickNotAny<typeof __VLS_internalComponent, new () => {}>>`;
+function* generateTemplate(options, ctx, isClassComponent) {
+    ctx.generatedTemplate = true;
+    if (!options.vueCompilerOptions.skipTemplateCodegen) {
+        const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
+            scriptSetupBindingNames: new Set(),
+            edited: options.edited,
+        });
+        yield* generateTemplateCtx(options, isClassComponent);
+        yield* generateTemplateComponents(options);
+        yield* generateTemplateBody(options, ctx, templateCodegenCtx);
+        yield* (0, internalComponent_1.generateInternalComponent)(options, ctx, templateCodegenCtx);
     }
     else {
-        yield `typeof this`;
-    }
-    /* CSS Module */
-    if (options.sfc.styles.some(style => style.module)) {
-        yield `& {${common_1.newLine}`;
-        for (let i = 0; i < options.sfc.styles.length; i++) {
-            const style = options.sfc.styles[i];
-            if (style.module) {
-                yield `${style.module}: Record<string, string> & ${ctx.helperTypes.Prettify.name}<{}`;
-                for (const className of style.classNames) {
-                    yield* generateCssClassProperty(i, className.text, className.offset, 'string', false);
-                }
-                yield `>${common_1.endOfLine}`;
-            }
-        }
-        yield `}`;
+        const templateUsageVars = [...getTemplateUsageVars(options, ctx)];
+        yield `// @ts-ignore${common_1.newLine}`;
+        yield `[${templateUsageVars.join(', ')}]${common_1.newLine}`;
+        yield `const __VLS_templateResult { slots: {}, refs: {}, attrs: {} }${common_1.endOfLine}`;
     }
-    yield common_1.endOfLine;
 }
-function* generateTemplateContext(options, templateCodegenCtx) {
-    /* Components */
-    yield `/* Components */${common_1.newLine}`;
-    yield `let __VLS_otherComponents!: NonNullable<typeof __VLS_internalComponent extends { components: infer C } ? C : {}> & typeof __VLS_componentsOption${common_1.endOfLine}`;
-    yield `let __VLS_own!: __VLS_SelfComponent<typeof __VLS_name, typeof __VLS_internalComponent & (new () => { ${(0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)}: typeof ${options.scriptSetupRanges?.slots?.name ?? '__VLS_slots'} })>${common_1.endOfLine}`;
-    yield `let __VLS_localComponents!: typeof __VLS_otherComponents & Omit<typeof __VLS_own, keyof typeof __VLS_otherComponents>${common_1.endOfLine}`;
-    yield `let __VLS_components!: typeof __VLS_localComponents & __VLS_GlobalComponents & typeof __VLS_ctx${common_1.endOfLine}`; // for html completion, TS references...
-    /* Style Scoped */
-    yield `/* Style Scoped */${common_1.newLine}`;
-    yield `type __VLS_StyleScopedClasses = {}`;
+function* generateTemplateBody(options, ctx, templateCodegenCtx) {
+    const firstClasses = new Set();
+    yield `let __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({
+                        source: 'style_' + i,
+                        className: className.text.slice(1),
+                        offset: className.offset + 1
+                    });
+                    continue;
+                }
+                firstClasses.add(className.text);
                 yield* generateCssClassProperty(i, className.text, className.offset, 'boolean', true);
             }
         }
     }
     yield common_1.endOfLine;
-    yield `let __VLS_styleScopedClasses!: __VLS_StyleScopedClasses | keyof __VLS_StyleScopedClasses | (keyof __VLS_StyleScopedClasses)[]${common_1.endOfLine}`;
+    yield* (0, styleScopedClasses_1.generateStyleScopedClasses)(templateCodegenCtx, true);
     yield* generateCssVars(options, templateCodegenCtx);
     if (options.templateCodegen) {
         for (const code of options.templateCodegen.codes) {
@@ -124,9 +119,15 @@ function* generateTemplateContext(options, templateCodegenCtx) {
         yield `// no template${common_1.newLine}`;
         if (!options.scriptSetupRanges?.slots.define) {
             yield `const __VLS_slots = {}${common_1.endOfLine}`;
+            yield `const __VLS_refs = {}${common_1.endOfLine}`;
+            yield `const __VLS_inheritedAttrs = {}${common_1.endOfLine}`;
         }
     }
-    yield `return ${options.scriptSetupRanges?.slots.name ?? '__VLS_slots'}${common_1.endOfLine}`;
+    yield `const __VLS_templateResult = {`;
+    yield `slots: ${options.scriptSetupRanges?.slots.name ?? '__VLS_slots'},${common_1.newLine}`;
+    yield `refs: __VLS_refs as ${ctx.localTypes.PickRefsExpose}<typeof __VLS_refs>,${common_1.newLine}`;
+    yield `attrs: {} as Partial<typeof __VLS_inheritedAttrs>,${common_1.newLine}`;
+    yield `}${common_1.endOfLine}`;
 }
 function* generateCssClassProperty(styleIndex, classNameWithDot, offset, propertyType, optional) {
     yield `${common_1.newLine} & { `;
@@ -134,7 +135,7 @@ function* generateCssClassProperty(styleIndex, classNameWithDot, offset, propert
         '',
         'style_' + styleIndex,
         offset,
-        index_1.codeFeatures.navigationWithoutRename,
+        index_1.codeFeatures.navigation,
     ];
     yield `'`;
     yield [

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

@@ -1,8 +1,9 @@
 import type * as CompilerDOM from '@vue/compiler-dom';
 import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenOptions } from './index';
+import { InlayHintInfo } from '../types';
 export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
-export declare function createTemplateCodegenContext(scriptSetupBindingNames: TemplateCodegenOptions['scriptSetupBindingNames']): {
+export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames' | 'edited'>): {
     slots: {
         name: string;
         loc?: number;
@@ -32,11 +33,15 @@ export declare function createTemplateCodegenContext(scriptSetupBindingNames: Te
     blockConditions: string[];
     usedComponentCtxVars: Set<string>;
     scopedClasses: {
+        source: string;
         className: string;
         offset: number;
     }[];
     emptyClassOffsets: number[];
+    inlayHints: InlayHintInfo[];
     hasSlot: boolean;
+    inheritedAttrVars: Set<unknown>;
+    singleRootNode: CompilerDOM.ElementNode | undefined;
     accessExternalVariable(name: string, offset?: number): void;
     hasLocalVariable: (name: string) => boolean;
     addLocalVariable: (name: string) => void;

package/lib/codegen/template/context.js

@@ -52,7 +52,7 @@ const _codeFeatures = {
         verification: true,
     },
 };
-function createTemplateCodegenContext(scriptSetupBindingNames) {
+function createTemplateCodegenContext(options) {
     let ignoredError = false;
     let expectErrorToken;
     let variableId = 0;
@@ -94,6 +94,7 @@ function createTemplateCodegenContext(scriptSetupBindingNames) {
     const usedComponentCtxVars = new Set();
     const scopedClasses = [];
     const emptyClassOffsets = [];
+    const inlayHints = [];
     return {
         slots,
         dynamicSlots,
@@ -104,7 +105,10 @@ function createTemplateCodegenContext(scriptSetupBindingNames) {
         usedComponentCtxVars,
         scopedClasses,
         emptyClassOffsets,
+        inlayHints,
         hasSlot: false,
+        inheritedAttrVars: new Set(),
+        singleRootNode: undefined,
         accessExternalVariable(name, offset) {
             let arr = accessExternalVariables.get(name);
             if (!arr) {
@@ -159,6 +163,9 @@ function createTemplateCodegenContext(scriptSetupBindingNames) {
             }
         },
         generateAutoImportCompletion: function* () {
+            if (!options.edited) {
+                return;
+            }
             const all = [...accessExternalVariables.entries()];
             if (!all.some(([_, offsets]) => offsets.size)) {
                 return;
@@ -167,7 +174,7 @@ function createTemplateCodegenContext(scriptSetupBindingNames) {
             yield `[`;
             for (const [varName, offsets] of all) {
                 for (const offset of offsets) {
-                    if (scriptSetupBindingNames.has(varName)) {
+                    if (options.scriptSetupBindingNames.has(varName)) {
                         // #3409
                         yield [
                             varName,

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

@@ -2,7 +2,7 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+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): Generator<Code>;
 export declare function getCanonicalComponentName(tagText: string): string;
 export declare function getPossibleOriginalComponentNames(tagText: string, deduplicate: boolean): string[];