@vue/language-core 2.2.4 → 2.2.6

package/lib/codegen/template/elementEvents.js

@@ -3,11 +3,13 @@ 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");
 const utils_1 = require("../utils");
 const camelized_1 = require("../utils/camelized");
+const wrapWith_1 = require("../utils/wrapWith");
 const interpolation_1 = require("./interpolation");
 function* generateElementEvents(options, ctx, node, componentFunctionalVar, componentVNodeVar, componentCtxVar) {
     let emitVar;
@@ -15,10 +17,8 @@ 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.loc.source.startsWith('[')
-            && !prop.arg.loc.source.endsWith(']')) {
+            && (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))) {
             ctx.currentComponent.used = true;
             if (!emitVar) {
                 emitVar = ctx.getInternalVariable();
@@ -28,21 +28,31 @@ 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;
-            let start = prop.arg.loc.start.offset;
-            let propPrefix = 'on';
+            let source = prop.arg?.loc.source ?? 'model-value';
+            let start = prop.arg?.loc.start.offset;
+            let propPrefix = 'on-';
             let emitPrefix = '';
-            if (source.startsWith('vue:')) {
+            if (prop.name === 'model') {
+                propPrefix = 'onUpdate:';
+                emitPrefix = 'update:';
+            }
+            else if (source.startsWith('vue:')) {
                 source = source.slice('vue:'.length);
                 start = start + 'vue:'.length;
-                propPrefix = 'onVnode';
+                propPrefix = 'onVnode-';
                 emitPrefix = 'vnode-';
             }
-            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}`;
+            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}`;
         }
     }
 }
@@ -51,13 +61,13 @@ function* generateEventArg(ctx, name, start, directive = 'on') {
         ...ctx.codeFeatures.withoutHighlightAndCompletion,
         ...ctx.codeFeatures.navigationWithoutRename,
     };
-    if (utils_1.variableNameRegex.test((0, shared_1.camelize)(name))) {
+    if (utils_1.identifierRegex.test((0, shared_1.camelize)(name))) {
         yield ['', 'template', start, features];
         yield directive;
-        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), start, utils_1.combineLastMapping);
+        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), 'template', start, utils_1.combineLastMapping);
     }
     else {
-        yield* (0, utils_1.wrapWith)(start, start + name.length, features, `'`, ['', 'template', start, utils_1.combineLastMapping], directive, ...(0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), start, utils_1.combineLastMapping), `'`);
+        yield* (0, wrapWith_1.wrapWith)(start, start + name.length, features, `'`, directive, ...(0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), 'template', start, utils_1.combineLastMapping), `'`);
     }
 }
 function* generateEventExpression(options, ctx, prop) {
@@ -105,6 +115,16 @@ 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/elementProps.js

@@ -12,6 +12,7 @@ const inlayHints_1 = require("../inlayHints");
 const utils_1 = require("../utils");
 const camelized_1 = require("../utils/camelized");
 const unicode_1 = require("../utils/unicode");
+const wrapWith_1 = require("../utils/wrapWith");
 const elementDirectives_1 = require("./elementDirectives");
 const elementEvents_1 = require("./elementEvents");
 const interpolation_1 = require("./interpolation");
@@ -80,14 +81,14 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const codes = (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(prop.arg
-                ? (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, codeInfo, prop.loc.name_2 ??= {}, shouldCamelize)
-                : (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.verification, propName)), `: `, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, enableCodeFeatures));
+            const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(prop.arg
+                    ? (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, codeInfo, prop.loc.name_2 ??= {}, shouldCamelize)
+                    : (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.withoutHighlightAndCompletion, propName)), `: `, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, enableCodeFeatures))];
             if (enableCodeFeatures) {
                 yield* codes;
             }
             else {
-                yield (0, muggle_string_1.toString)([...codes]);
+                yield (0, muggle_string_1.toString)(codes);
             }
             if (shouldSpread) {
                 yield ` }`;
@@ -99,12 +100,12 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
                         ? `[__VLS_tryAsConstant(\`$\{${prop.arg.content}\}Modifiers\`)]`
                         : (0, shared_1.camelize)(propName) + `Modifiers`
                     : `modelModifiers`;
-                const codes = (0, elementDirectives_1.generateModifiers)(options, ctx, prop, propertyName);
+                const codes = [...(0, elementDirectives_1.generateModifiers)(options, ctx, prop, propertyName)];
                 if (enableCodeFeatures) {
                     yield* codes;
                 }
                 else {
-                    yield (0, muggle_string_1.toString)([...codes]);
+                    yield (0, muggle_string_1.toString)(codes);
                 }
                 yield utils_1.newLine;
             }
@@ -123,14 +124,14 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const codes = (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, codeInfo, prop.loc.name_1 ??= {}, shouldCamelize), `: `, ...(prop.value
-                ? generateAttrValue(prop.value, ctx.codeFeatures.withoutNavigation)
-                : [`true`]));
+            const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, codeInfo, prop.loc.name_1 ??= {}, shouldCamelize), `: `, ...(prop.value
+                    ? generateAttrValue(prop.value, ctx.codeFeatures.withoutNavigation)
+                    : [`true`]))];
             if (enableCodeFeatures) {
                 yield* codes;
             }
             else {
-                yield (0, muggle_string_1.toString)([...codes]);
+                yield (0, muggle_string_1.toString)(codes);
             }
             if (shouldSpread) {
                 yield ` }`;
@@ -147,12 +148,12 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
                 }
             }
             else {
-                const codes = (0, utils_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, `...`, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, enableCodeFeatures));
+                const codes = [...(0, wrapWith_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, `...`, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, enableCodeFeatures))];
                 if (enableCodeFeatures) {
                     yield* codes;
                 }
                 else {
-                    yield (0, muggle_string_1.toString)([...codes]);
+                    yield (0, muggle_string_1.toString)(codes);
                 }
                 yield `,${utils_1.newLine}`;
             }
@@ -173,10 +174,10 @@ function* generatePropExp(options, ctx, prop, exp, features, enableCodeFeatures
         }
         else {
             const propVariableName = (0, shared_1.camelize)(exp.loc.source);
-            if (utils_1.variableNameRegex.test(propVariableName)) {
+            if (utils_1.identifierRegex.test(propVariableName)) {
                 const isDestructuredProp = options.destructuredPropNames?.has(propVariableName) ?? false;
                 const isTemplateRef = options.templateRefNames?.has(propVariableName) ?? false;
-                const codes = (0, camelized_1.generateCamelized)(exp.loc.source, exp.loc.start.offset, features);
+                const codes = (0, camelized_1.generateCamelized)(exp.loc.source, 'template', exp.loc.start.offset, features);
                 if (ctx.hasLocalVariable(propVariableName) || isDestructuredProp) {
                     yield* codes;
                 }

package/lib/codegen/template/index.js

@@ -5,6 +5,7 @@ exports.forEachElementNode = forEachElementNode;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("../../utils/shared");
 const utils_1 = require("../utils");
+const wrapWith_1 = require("../utils/wrapWith");
 const context_1 = require("./context");
 const objectProperty_1 = require("./objectProperty");
 const styleScopedClasses_1 = require("./styleScopedClasses");
@@ -62,7 +63,7 @@ function* generateSlots(options, ctx) {
                 yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, ctx.codeFeatures.withoutHighlightAndCompletion, slot.nodeLoc);
             }
             else {
-                yield* (0, utils_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+                yield* (0, wrapWith_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
             }
             yield `?: (props: typeof ${slot.propsVar}) => any }`;
         }

package/lib/codegen/template/objectProperty.js

@@ -5,6 +5,7 @@ const shared_1 = require("@vue/shared");
 const utils_1 = require("../utils");
 const camelized_1 = require("../utils/camelized");
 const stringLiteralKey_1 = require("../utils/stringLiteralKey");
+const wrapWith_1 = require("../utils/wrapWith");
 const interpolation_1 = require("./interpolation");
 function* generateObjectProperty(options, ctx, code, offset, features, astHolder, shouldCamelize = false, shouldBeConstant = false) {
     if (code.startsWith('[') && code.endsWith(']') && astHolder) {
@@ -16,15 +17,15 @@ function* generateObjectProperty(options, ctx, code, offset, features, astHolder
         }
     }
     else if (shouldCamelize) {
-        if (utils_1.variableNameRegex.test((0, shared_1.camelize)(code))) {
-            yield* (0, camelized_1.generateCamelized)(code, offset, features);
+        if (utils_1.identifierRegex.test((0, shared_1.camelize)(code))) {
+            yield* (0, camelized_1.generateCamelized)(code, 'template', offset, features);
         }
         else {
-            yield* (0, utils_1.wrapWith)(offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, offset, utils_1.combineLastMapping), `'`);
+            yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, 'template', offset, utils_1.combineLastMapping), `'`);
         }
     }
     else {
-        if (utils_1.variableNameRegex.test(code)) {
+        if (utils_1.identifierRegex.test(code)) {
             yield [code, 'template', offset, features];
         }
         else {

package/lib/codegen/template/propertyAccess.js

@@ -5,7 +5,7 @@ const utils_1 = require("../utils");
 const stringLiteralKey_1 = require("../utils/stringLiteralKey");
 const interpolation_1 = require("./interpolation");
 function* generatePropertyAccess(options, ctx, code, offset, features, astHolder) {
-    if (!options.compilerOptions.noPropertyAccessFromIndexSignature && utils_1.variableNameRegex.test(code)) {
+    if (!options.compilerOptions.noPropertyAccessFromIndexSignature && utils_1.identifierRegex.test(code)) {
         yield `.`;
         yield offset !== undefined && features
             ? [code, 'template', offset, features]

package/lib/codegen/template/slotOutlet.js

@@ -4,6 +4,7 @@ exports.generateSlotOutlet = generateSlotOutlet;
 const CompilerDOM = require("@vue/compiler-dom");
 const inlayHints_1 = require("../inlayHints");
 const utils_1 = require("../utils");
+const wrapWith_1 = require("../utils/wrapWith");
 const elementChildren_1 = require("./elementChildren");
 const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
@@ -45,13 +46,13 @@ function* generateSlotOutlet(options, ctx, node) {
             else {
                 codes = [`['default']`];
             }
-            yield* (0, utils_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}`, ...codes);
+            yield* (0, wrapWith_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}`, ...codes);
         }
         else {
-            yield* (0, utils_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, utils_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `'default'`), `]`);
+            yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `'default'`), `]`);
         }
         yield `)(`;
-        yield* (0, utils_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true, true), `}`);
+        yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true, true), `}`);
         yield `)${utils_1.endOfLine}`;
     }
     else {

package/lib/codegen/template/styleScopedClasses.js

@@ -5,6 +5,9 @@ exports.collectStyleScopedClassReferences = collectStyleScopedClassReferences;
 const CompilerDOM = require("@vue/compiler-dom");
 const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
 const utils_1 = require("../utils");
+const escaped_1 = require("../utils/escaped");
+const wrapWith_1 = require("../utils/wrapWith");
+const classNameEscapeRegex = /([\\'])/;
 function* generateStyleScopedClassReferences(ctx, withDot = false) {
     for (const offset of ctx.emptyClassOffsets) {
         yield `/** @type {__VLS_StyleScopedClasses['`;
@@ -18,58 +21,9 @@ function* generateStyleScopedClassReferences(ctx, withDot = false) {
     }
     for (const { source, className, offset } of ctx.scopedClasses) {
         yield `/** @type {__VLS_StyleScopedClasses[`;
-        yield [
-            '',
-            source,
-            offset - (withDot ? 1 : 0),
-            ctx.codeFeatures.navigation,
-        ];
-        yield `'`;
-        // fix https://github.com/vuejs/language-tools/issues/4537
-        yield* escapeString(source, className, offset, ['\\', '\'']);
-        yield `'`;
-        yield [
-            '',
-            source,
-            offset + className.length,
-            ctx.codeFeatures.navigation,
-        ];
+        yield* (0, wrapWith_1.wrapWith)(offset - (withDot ? 1 : 0), offset + className.length, source, ctx.codeFeatures.navigation, `'`, ...(0, escaped_1.generateEscaped)(className, source, offset, ctx.codeFeatures.navigationAndAdditionalCompletion, classNameEscapeRegex), `'`);
         yield `]} */${utils_1.endOfLine}`;
     }
-    function* escapeString(source, className, offset, escapeTargets) {
-        let count = 0;
-        const currentEscapeTargets = [...escapeTargets];
-        const firstEscapeTarget = currentEscapeTargets.shift();
-        const splitted = className.split(firstEscapeTarget);
-        for (let i = 0; i < splitted.length; i++) {
-            const part = splitted[i];
-            const partLength = part.length;
-            if (escapeTargets.length > 0) {
-                yield* escapeString(source, part, offset + count, [...currentEscapeTargets]);
-            }
-            else {
-                yield [
-                    part,
-                    source,
-                    offset + count,
-                    ctx.codeFeatures.navigationAndAdditionalCompletion,
-                ];
-            }
-            if (i !== splitted.length - 1) {
-                yield '\\';
-                yield [
-                    firstEscapeTarget,
-                    source,
-                    offset + count + partLength,
-                    ctx.codeFeatures.navigationAndAdditionalCompletion,
-                ];
-                count += partLength + 1;
-            }
-            else {
-                count += partLength;
-            }
-        }
-    }
 }
 function collectStyleScopedClassReferences(options, ctx, node) {
     for (const prop of node.props) {

package/lib/codegen/template/vIf.js

@@ -21,12 +21,8 @@ function* generateVIf(options, ctx, node) {
         }
         let addedBlockCondition = false;
         if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-            const codes = [
-                ...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, branch.condition.loc, `(`, `)`),
-            ];
-            for (const code of codes) {
-                yield code;
-            }
+            const codes = [...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, branch.condition.loc, `(`, `)`)];
+            yield* codes;
             ctx.blockConditions.push((0, muggle_string_1.toString)(codes));
             addedBlockCondition = true;
             yield ` `;

package/lib/codegen/template/vSlot.js

@@ -4,6 +4,7 @@ exports.generateVSlot = generateVSlot;
 exports.generateImplicitDefaultSlot = generateImplicitDefaultSlot;
 const CompilerDOM = require("@vue/compiler-dom");
 const utils_1 = require("../utils");
+const wrapWith_1 = require("../utils/wrapWith");
 const objectProperty_1 = require("./objectProperty");
 const templateChild_1 = require("./templateChild");
 function* generateVSlot(options, ctx, node, slotDir) {
@@ -18,7 +19,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
         yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
     }
     else {
-        yield* (0, utils_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+        yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
     }
     yield `: __VLS_thisSlot } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
     if (slotDir.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -85,7 +86,7 @@ function* generateImplicitDefaultSlot(ctx, node) {
     if (node.children.length) {
         ctx.currentComponent.used = true;
         yield `${ctx.currentComponent.ctxVar}.slots!.`;
-        yield* (0, utils_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
+        yield* (0, wrapWith_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
         yield utils_1.endOfLine;
     }
 }

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

@@ -1,2 +1,2 @@
 import type { Code, VueCodeInformation } from '../../types';
-export declare function generateCamelized(code: string, offset: number, info: VueCodeInformation): Generator<Code>;
+export declare function generateCamelized(code: string, source: string, offset: number, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/camelized.js

@@ -2,26 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCamelized = generateCamelized;
 const shared_1 = require("@vue/shared");
-const index_1 = require("./index");
-function* generateCamelized(code, offset, info) {
+function* generateCamelized(code, source, offset, features) {
     const parts = code.split('-');
+    const startCombineOffset = features.__combineOffset ?? 0;
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
         if (part !== '') {
             if (i === 0) {
                 yield [
                     part,
-                    'template',
+                    source,
                     offset,
-                    info,
+                    features,
                 ];
             }
             else {
                 yield [
                     (0, shared_1.capitalize)(part),
-                    'template',
+                    source,
                     offset,
-                    index_1.combineLastMapping,
+                    { __combineOffset: startCombineOffset + i },
                 ];
             }
         }

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

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from "../../types";
+export declare function generateEscaped(text: string, source: string, offset: number, features: VueCodeInformation, escapeTarget: RegExp): Generator<Code>;

package/lib/codegen/utils/escaped.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEscaped = generateEscaped;
+function* generateEscaped(text, source, offset, features, escapeTarget) {
+    const parts = text.split(escapeTarget);
+    const startCombineOffset = features.__combineOffset ?? 0;
+    let isEscapeTarget = false;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (isEscapeTarget) {
+            yield `\\`;
+        }
+        yield [
+            part,
+            source,
+            offset,
+            i === 0 ? features : { __combineOffset: startCombineOffset + i },
+        ];
+        offset += part.length;
+        isEscapeTarget = !isEscapeTarget;
+    }
+}
+//# sourceMappingURL=escaped.js.map

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

@@ -4,8 +4,7 @@ import type { Code, SfcBlock, SfcBlockAttr, VueCodeInformation } from '../../typ
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
-export declare const variableNameRegex: RegExp;
-export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
+export declare const identifierRegex: RegExp;
 export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[]): string[];
 export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
     id: ts.Identifier;

package/lib/codegen/utils/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
-exports.wrapWith = wrapWith;
+exports.identifierRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
 exports.collectVars = collectVars;
 exports.collectIdentifiers = collectIdentifiers;
 exports.normalizeAttributeValue = normalizeAttributeValue;
@@ -12,18 +11,7 @@ const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
 exports.combineLastMapping = { __combineOffset: 1 };
-exports.variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
-    yield ['', 'template', startOffset, features];
-    let offset = 1;
-    for (const wrapCode of wrapCodes) {
-        if (typeof wrapCode !== 'string') {
-            offset++;
-        }
-        yield wrapCode;
-    }
-    yield ['', 'template', endOffset, { __combineOffset: offset }];
-}
+exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
 function collectVars(ts, node, ast, results = []) {
     const identifiers = collectIdentifiers(ts, node, []);
     for (const { id } of identifiers) {

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,41 @@
+"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

package/lib/codegen/utils/stringLiteralKey.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStringLiteralKey = generateStringLiteralKey;
 const index_1 = require("./index");
+const wrapWith_1 = require("./wrapWith");
 function* generateStringLiteralKey(code, offset, info) {
     if (offset === undefined || !info) {
         yield `'${code}'`;
     }
     else {
-        yield* (0, index_1.wrapWith)(offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
+        yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
     }
 }
 //# sourceMappingURL=stringLiteralKey.js.map

package/lib/codegen/utils/unicode.js

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

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

@@ -0,0 +1,3 @@
+import type { Code, VueCodeInformation } from "../../types";
+export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;
+export declare function wrapWith(startOffset: number, endOffset: number, source: string, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;

package/lib/codegen/utils/wrapWith.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapWith = wrapWith;
+function* wrapWith(startOffset, endOffset, ...args) {
+    let source = 'template';
+    let features;
+    let codes;
+    if (typeof args[0] === 'string') {
+        [source, features, ...codes] = args;
+    }
+    else {
+        [features, ...codes] = args;
+    }
+    yield ['', source, startOffset, features];
+    let offset = 1;
+    for (const code of codes) {
+        if (typeof code !== 'string') {
+            offset++;
+        }
+        yield code;
+    }
+    yield ['', source, endOffset, { __combineOffset: offset }];
+}
+//# sourceMappingURL=wrapWith.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -15,6 +15,8 @@ type DefineProp = {
     defaultValue?: TextRange;
     required?: boolean;
     isModel?: boolean;
+    comments?: TextRange;
+    argNode?: ts.Expression;
 };
 type DefineProps = CallExpressionRange & {
     name?: string;