@vue/language-core 2.2.6 → 2.2.10

package/lib/codegen/globalTypes.js

@@ -100,9 +100,6 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: infer Ctx } ? Ctx : never : any
 		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
 	>>;
-	type __VLS_OmitStringIndex<T> = {
-		[K in keyof T as string extends K ? never : K]: T[K];
-	};
 	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
 
 	function __VLS_getVForSourceType<T extends number | string | any[] | Iterable<any>>(source: T): [
@@ -144,7 +141,7 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		: (_: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'} } };
 	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
 	function __VLS_asFunctionalElement<T>(tag: T, endTag?: T): (attrs: T${checkUnknownComponents ? '' : ' & Record<string, unknown>'}) => void;
-	function __VLS_asFunctionalSlot<S>(slot: S): (props: NonNullable<S> extends (props: infer P) => any ? P : {}) => void;
+	function __VLS_asFunctionalSlot<S>(slot: S): S extends () => infer R ? (props: {}) => R : NonNullable<S>;
 	function __VLS_tryAsConstant<const T>(t: T): T;
 }
 `;

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

@@ -164,6 +164,7 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     getInternalVariable: () => string;
     getHoistVariable: (originalVar: string) => string;
     generateHoistVariables: () => Generator<string, void, unknown>;
+    generateConditionGuards: () => Generator<string, void, unknown>;
     ignoreError: () => Generator<Code>;
     expectError: (prevNode: CompilerDOM.CommentNode) => Generator<Code>;
     resetDirectiveComments: (endStr: string) => Generator<Code>;

package/lib/codegen/template/context.js

@@ -210,6 +210,11 @@ function createTemplateCodegenContext(options) {
                 yield utils_1.endOfLine;
             }
         },
+        generateConditionGuards: function* () {
+            for (const condition of blockConditions) {
+                yield `if (!${condition}) return${utils_1.endOfLine}`;
+            }
+        },
         ignoreError: function* () {
             if (!ignoredError) {
                 ignoredError = true;

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

@@ -6,5 +6,4 @@ import type { TemplateCodegenOptions } from './index';
 export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentFunctionalVar: string, componentVNodeVar: string, componentCtxVar: string): Generator<Code>;
 export declare function generateEventArg(ctx: TemplateCodegenContext, name: string, start: number, directive?: string): Generator<Code>;
 export declare function generateEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
-export declare function generateModelEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
 export declare function isCompoundExpression(ts: typeof import('typescript'), ast: ts.SourceFile): boolean;

package/lib/codegen/template/elementEvents.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateElementEvents = generateElementEvents;
 exports.generateEventArg = generateEventArg;
 exports.generateEventExpression = generateEventExpression;
-exports.generateModelEventExpression = generateModelEventExpression;
 exports.isCompoundExpression = isCompoundExpression;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("@vue/shared");
@@ -17,8 +16,9 @@ function* generateElementEvents(options, ctx, node, componentFunctionalVar, comp
     let propsVar;
     for (const prop of node.props) {
         if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && (prop.name === 'on' && (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic)
-                || prop.name === 'model' && (!prop.arg || prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))) {
+            && prop.name === 'on'
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.arg.isStatic) {
             ctx.currentComponent.used = true;
             if (!emitVar) {
                 emitVar = ctx.getInternalVariable();
@@ -28,31 +28,21 @@ function* generateElementEvents(options, ctx, node, componentFunctionalVar, comp
                 yield `let ${eventsVar}!: __VLS_NormalizeEmits<typeof ${emitVar}>${utils_1.endOfLine}`;
                 yield `let ${propsVar}!: __VLS_FunctionalComponentProps<typeof ${componentFunctionalVar}, typeof ${componentVNodeVar}>${utils_1.endOfLine}`;
             }
-            let source = prop.arg?.loc.source ?? 'model-value';
-            let start = prop.arg?.loc.start.offset;
-            let propPrefix = 'on-';
+            let source = prop.arg.loc.source;
+            let start = prop.arg.loc.start.offset;
+            let propPrefix = 'on';
             let emitPrefix = '';
-            if (prop.name === 'model') {
-                propPrefix = 'onUpdate:';
-                emitPrefix = 'update:';
-            }
-            else if (source.startsWith('vue:')) {
+            if (source.startsWith('vue:')) {
                 source = source.slice('vue:'.length);
                 start = start + 'vue:'.length;
-                propPrefix = 'onVnode-';
+                propPrefix = 'onVnode';
                 emitPrefix = 'vnode-';
             }
-            yield `(): __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${eventsVar}, '${(0, shared_1.camelize)(propPrefix + source)}', '${emitPrefix + source}', '${(0, shared_1.camelize)(emitPrefix + source)}'> => ({${utils_1.newLine}`;
-            if (prop.name === 'on') {
-                yield* generateEventArg(ctx, source, start, propPrefix.slice(0, -1));
-                yield `: `;
-                yield* generateEventExpression(options, ctx, prop);
-            }
-            else {
-                yield `'${(0, shared_1.camelize)(propPrefix + source)}': `;
-                yield* generateModelEventExpression(options, ctx, prop);
-            }
-            yield `})${utils_1.endOfLine}`;
+            yield `const ${ctx.getInternalVariable()}: __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${eventsVar}, '${(0, shared_1.camelize)(propPrefix + '-' + source)}', '${emitPrefix}${source}', '${(0, shared_1.camelize)(emitPrefix + source)}'> = {${utils_1.newLine}`;
+            yield* generateEventArg(ctx, source, start, propPrefix);
+            yield `: `;
+            yield* generateEventExpression(options, ctx, prop);
+            yield `}${utils_1.endOfLine}`;
         }
     }
 }
@@ -80,11 +70,9 @@ function* generateEventExpression(options, ctx, prop) {
         if (_isCompoundExpression) {
             yield `(...[$event]) => {${utils_1.newLine}`;
             ctx.addLocalVariable('$event');
+            yield* ctx.generateConditionGuards();
             prefix = ``;
             suffix = ``;
-            for (const blockCondition of ctx.blockConditions) {
-                prefix += `if (!${blockCondition}) return${utils_1.endOfLine}`;
-            }
         }
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', offset => {
             if (_isCompoundExpression && isFirstMapping) {
@@ -115,16 +103,6 @@ function* generateEventExpression(options, ctx, prop) {
         yield `() => {}`;
     }
 }
-function* generateModelEventExpression(options, ctx, prop) {
-    if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        yield `(...[$event]) => (`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.verification, prop.exp.content, prop.exp.loc.start.offset, prop.exp.loc);
-        yield ` = $event)`;
-    }
-    else {
-        yield `() => {}`;
-    }
-}
 function isCompoundExpression(ts, ast) {
     let result = true;
     if (ast.statements.length === 0) {

package/lib/codegen/template/index.js

@@ -52,8 +52,7 @@ function* generateTemplate(options) {
 }
 function* generateSlots(options, ctx) {
     if (!options.hasDefineSlots) {
-        const name = (0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target);
-        yield `type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.${name}>`;
+        yield `type __VLS_Slots = {}`;
         for (const { expVar, propsVar } of ctx.dynamicSlots) {
             yield `${utils_1.newLine}& { [K in NonNullable<typeof ${expVar}>]?: (props: typeof ${propsVar}) => any }`;
         }
@@ -67,7 +66,7 @@ function* generateSlots(options, ctx) {
             }
             yield `?: (props: typeof ${slot.propsVar}) => any }`;
         }
-        yield `>${utils_1.endOfLine}`;
+        yield `${utils_1.endOfLine}`;
     }
     return `__VLS_Slots`;
 }

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

@@ -201,6 +201,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         getInternalVariable: () => string;
         getHoistVariable: (originalVar: string) => string;
         generateHoistVariables: () => Generator<string, void, unknown>;
+        generateConditionGuards: () => Generator<string, void, unknown>;
         ignoreError: () => Generator<Code>;
         expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
         resetDirectiveComments: (endStr: string) => Generator<Code>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.2.6",
+	"version": "2.2.10",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "f2088e256dc0220db9549d28d9f865a5711dcfbe"
+	"gitHead": "0422c03ffa4958431c9cd3cd19ae51f726c30b07"
 }

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

@@ -1,4 +0,0 @@
-import type { Code } from '../../types';
-import type { ScriptCodegenContext } from './context';
-import { ScriptCodegenOptions } from './index';
-export declare function generateStyleModulesType(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;

package/lib/codegen/script/styleModulesType.js

@@ -1,34 +0,0 @@
-"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");
-function* generateStyleModulesType(options, ctx) {
-    const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
-    if (!styles.length && !options.scriptSetupRanges?.useCssModule.length) {
-        return;
-    }
-    yield `type __VLS_StyleModules = {${utils_1.newLine}`;
-    for (const [style, i] of styles) {
-        const { name, offset } = style.module;
-        if (offset) {
-            yield [
-                name,
-                'main',
-                offset + 1,
-                index_1.codeFeatures.all
-            ];
-        }
-        else {
-            yield name;
-        }
-        yield `: Record<string, string> & ${ctx.localTypes.PrettifyLocal}<{}`;
-        for (const className of style.classNames) {
-            yield* (0, template_1.generateCssClassProperty)(i, className.text, className.offset, 'string', false);
-        }
-        yield `>${utils_1.endOfLine}`;
-    }
-    yield `}${utils_1.endOfLine}`;
-}
-//# sourceMappingURL=styleModulesType.js.map

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

@@ -1,3 +0,0 @@
-import type { Code, VueCodeInformation } from '../../types';
-export declare function getObjectProperty(code: string): string;
-export declare function generateObjectProperty(code: string, source: string, offset: number, features: VueCodeInformation, hasQuotes?: boolean, shouldCamelize?: boolean): Generator<Code>;

package/lib/codegen/utils/objectProperty.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getObjectProperty = getObjectProperty;
-exports.generateObjectProperty = generateObjectProperty;
-const shared_1 = require("@vue/shared");
-const utils_1 = require("../utils");
-const camelized_1 = require("../utils/camelized");
-const stringLiteralKey_1 = require("../utils/stringLiteralKey");
-function getObjectProperty(code) {
-    if (utils_1.identifierRegex.test(code)) {
-        return code;
-    }
-    else {
-        return `'${code}'`;
-    }
-}
-function* generateObjectProperty(code, source, offset, features, hasQuotes = false, shouldCamelize = false) {
-    const start = offset;
-    const end = offset + code.length;
-    if (hasQuotes) {
-        code = code.slice(1, -1);
-        offset++;
-    }
-    if (shouldCamelize) {
-        if (utils_1.identifierRegex.test((0, shared_1.camelize)(code))) {
-            yield* (0, camelized_1.generateCamelized)(code, source, offset, features);
-        }
-        else {
-            yield* (0, utils_1.wrapWith)(start, end, source, features, `'`, ...(0, camelized_1.generateCamelized)(code, source, offset, features), `'`);
-        }
-    }
-    else {
-        if (utils_1.identifierRegex.test(code)) {
-            yield [code, source, offset, features];
-        }
-        else {
-            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, source, offset, features);
-        }
-    }
-}
-//# sourceMappingURL=objectProperty.js.map