@vue/language-core 2.1.10 → 2.2.0

package/lib/codegen/template/vFor.js

@@ -3,17 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVFor = generateVFor;
 exports.parseVForNode = parseVForNode;
 const CompilerDOM = require("@vue/compiler-dom");
-const common_1 = require("../common");
+const utils_1 = require("../utils");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
-function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
+function* generateVFor(options, ctx, node) {
     const { source } = node.parseResult;
     const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
     const forBlockVars = [];
     yield `for (const [`;
     if (leftExpressionRange && leftExpressionText) {
-        const collectAst = (0, common_1.createTsAst)(options.ts, node.parseResult, `const [${leftExpressionText}]`);
-        (0, common_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
+        const collectAst = (0, utils_1.createTsAst)(options.ts, node.parseResult, `const [${leftExpressionText}]`);
+        (0, utils_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
         yield [
             leftExpressionText,
             'template',
@@ -24,13 +24,13 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
     yield `] of `;
     if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         yield `__VLS_getVForSourceType(`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, source.content, source.loc, source.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, source.content, source.loc.start.offset, source.loc, '(', ')');
         yield `!)`; // #3102
     }
     else {
         yield `{} as any`;
     }
-    yield `) {${common_1.newLine}`;
+    yield `) {${utils_1.newLine}`;
     for (const varName of forBlockVars) {
         ctx.addLocalVariable(varName);
     }
@@ -46,8 +46,8 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
             for (const prop of argument.returns.props.properties) {
                 if (prop.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                     && !prop.value.isStatic) {
-                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.value.content, prop.value.loc, prop.value.loc.start.offset, ctx.codeFeatures.all, '(', ')');
-                    yield common_1.endOfLine;
+                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, prop.value.loc, '(', ')');
+                    yield utils_1.endOfLine;
                 }
             }
         }
@@ -57,14 +57,14 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
     }
     let prev;
     for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar, true);
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev, true);
         prev = childNode;
     }
     for (const varName of forBlockVars) {
         ctx.removeLocalVariable(varName);
     }
     yield* ctx.generateAutoImportCompletion();
-    yield `}${common_1.newLine}`;
+    yield `}${utils_1.newLine}`;
 }
 function parseVForNode(node) {
     const { value, key, index } = node.parseResult;
@@ -75,7 +75,7 @@ function parseVForNode(node) {
         }
         : undefined;
     const leftExpressionText = leftExpressionRange
-        ? node.loc.source.substring(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
+        ? node.loc.source.slice(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
         : undefined;
     return {
         leftExpressionRange,

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

@@ -2,4 +2,4 @@ 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 generateVIf(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.IfNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateVIf(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.IfNode): Generator<Code>;

package/lib/codegen/template/vIf.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVIf = generateVIf;
 const CompilerDOM = require("@vue/compiler-dom");
 const muggle_string_1 = require("muggle-string");
-const common_1 = require("../common");
+const utils_1 = require("../utils");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
-function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
+function* generateVIf(options, ctx, node) {
     let originalBlockConditionsLength = ctx.blockConditions.length;
     for (let i = 0; i < node.branches.length; i++) {
         const branch = node.branches[i];
@@ -22,7 +22,7 @@ function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
         let addedBlockCondition = false;
         if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
             const codes = [
-                ...(0, interpolation_1.generateInterpolation)(options, ctx, branch.condition.content, branch.condition.loc, branch.condition.loc.start.offset, ctx.codeFeatures.all, '(', ')'),
+                ...(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;
@@ -31,17 +31,17 @@ function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
             addedBlockCondition = true;
             yield ` `;
         }
-        yield `{${common_1.newLine}`;
+        yield `{${utils_1.newLine}`;
         if (isFragment(node)) {
             yield* ctx.resetDirectiveComments('end of v-if start');
         }
         let prev;
         for (const childNode of branch.children) {
-            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
             prev = childNode;
         }
         yield* ctx.generateAutoImportCompletion();
-        yield `}${common_1.newLine}`;
+        yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {
             ctx.blockConditions[ctx.blockConditions.length - 1] = `!(${ctx.blockConditions[ctx.blockConditions.length - 1]})`;
         }

package/lib/codegen/{template → utils}/camelized.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCamelized = generateCamelized;
 const shared_1 = require("@vue/shared");
-const common_1 = require("../common");
+const index_1 = require("./index");
 function* generateCamelized(code, offset, info) {
     const parts = code.split('-');
     for (let i = 0; i < parts.length; i++) {
@@ -21,7 +21,7 @@ function* generateCamelized(code, offset, info) {
                     (0, shared_1.capitalize)(part),
                     'template',
                     offset,
-                    common_1.combineLastMapping,
+                    index_1.combineLastMapping,
                 ];
             }
         }

package/lib/codegen/{common.d.ts → utils/index.d.ts}

@@ -1,10 +1,9 @@
 import type * as ts from 'typescript';
-import type { Code, SfcBlock, VueCodeInformation } from '../types';
+import type { Code, SfcBlock, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
 export declare const variableNameRegex: RegExp;
-export declare function conditionWrapWith(condition: boolean, startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
 export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
 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, isRest: boolean][], isRest?: boolean): [id: ts.Identifier, isRest: boolean][];

package/lib/codegen/{common.js → utils/index.js}

@@ -1,27 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
-exports.conditionWrapWith = conditionWrapWith;
 exports.wrapWith = wrapWith;
 exports.collectVars = collectVars;
 exports.collectIdentifiers = collectIdentifiers;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
-const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
-exports.newLine = '\n';
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
 exports.combineLastMapping = { __combineLastMapping: true };
 exports.variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-function* conditionWrapWith(condition, startOffset, endOffset, features, ...wrapCodes) {
-    if (condition) {
-        yield* wrapWith(startOffset, endOffset, features, ...wrapCodes);
-    }
-    else {
-        for (const wrapCode of wrapCodes) {
-            yield wrapCode;
-        }
-    }
-}
 function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
     yield ['', 'template', startOffset, features];
     let offset = 1;
@@ -70,10 +59,10 @@ function createTsAst(ts, astHolder, text) {
 }
 function generateSfcBlockSection(block, start, end, features) {
     return [
-        block.content.substring(start, end),
+        block.content.slice(start, end),
         block.name,
         start,
         features,
     ];
 }
-//# sourceMappingURL=common.js.map
+//# sourceMappingURL=index.js.map

package/lib/codegen/{template → utils}/stringLiteralKey.js

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

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

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

package/lib/codegen/utils/unicode.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnicode = generateUnicode;
+const index_1 = require("./index");
+function* generateUnicode(code, offset, info) {
+    if (needToUnicode(code)) {
+        yield* (0, index_1.wrapWith)(offset, offset + code.length, info, toUnicode(code));
+    }
+    else {
+        yield [code, 'template', offset, info];
+    }
+}
+function needToUnicode(str) {
+    return str.includes('\\') || str.includes('\n');
+}
+function toUnicode(str) {
+    return str.split('').map(value => {
+        const temp = value.charCodeAt(0).toString(16).padStart(4, '0');
+        if (temp.length > 2) {
+            return '\\u' + temp;
+        }
+        return value;
+    }).join('');
+}
+//# sourceMappingURL=unicode.js.map

package/lib/languagePlugin.js

@@ -90,7 +90,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
             getServiceScript(root) {
                 for (const code of (0, language_core_1.forEachEmbeddedCode)(root)) {
                     if (/script_(js|jsx|ts|tsx)/.test(code.id)) {
-                        const lang = code.id.substring('script_'.length);
+                        const lang = code.id.slice('script_'.length);
                         return {
                             code,
                             extension: '.' + lang,

package/lib/parsers/scriptRanges.d.ts

@@ -1,5 +1,5 @@
-import type { TextRange } from '../types';
 import type * as ts from 'typescript';
+import type { TextRange } from '../types';
 export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 }
 export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean, withNode: boolean): {
@@ -14,5 +14,10 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), ast:
         inheritAttrsOption: string | undefined;
     }) | undefined;
     classBlockEnd: number | undefined;
-    bindings: TextRange[];
+    bindings: {
+        range: TextRange;
+        moduleName?: string;
+        isDefaultImport?: boolean;
+        isNamespace?: boolean;
+    }[];
 };

package/lib/parsers/scriptSetupRanges.d.ts

@@ -1,91 +1,75 @@
 import type * as ts from 'typescript';
-import type { VueCompilerOptions, TextRange } from '../types';
+import type { TextRange, VueCompilerOptions } from '../types';
+type CallExpressionRange = {
+    callExp: TextRange;
+    exp: TextRange;
+    arg?: TextRange;
+    typeArg?: TextRange;
+};
+type DefineProp = {
+    localName?: TextRange;
+    name?: TextRange;
+    type?: TextRange;
+    modifierType?: TextRange;
+    runtimeType?: TextRange;
+    defaultValue?: TextRange;
+    required?: boolean;
+    isModel?: boolean;
+};
+type DefineProps = CallExpressionRange & {
+    name?: string;
+    destructured?: Set<string>;
+    destructuredRest?: string;
+    statement: TextRange;
+};
+type WithDefaults = Pick<CallExpressionRange, 'callExp' | 'exp' | 'arg'>;
+type DefineEmits = CallExpressionRange & {
+    name?: string;
+    hasUnionTypeArg?: boolean;
+    statement: TextRange;
+};
+type DefineSlots = CallExpressionRange & {
+    name?: string;
+    isObjectBindingPattern?: boolean;
+    statement: TextRange;
+};
+type DefineOptions = {
+    name?: string;
+    inheritAttrs?: string;
+};
+type UseTemplateRef = CallExpressionRange & {
+    name?: string;
+};
 export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
 }
 export declare function parseScriptSetupRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
     leadingCommentEndOffset: number;
     importSectionEndOffset: number;
-    bindings: TextRange[];
-    importComponentNames: Set<string>;
-    props: {
-        name?: string;
-        destructured?: Set<string>;
-        destructuredRest?: string;
-        define?: ReturnType<(node: ts.CallExpression) => TextRange & {
-            exp: TextRange;
-            arg?: TextRange;
-            typeArg?: TextRange;
-        }> & {
-            statement: TextRange;
-        };
-        withDefaults?: TextRange & {
-            arg?: TextRange;
-        };
-    };
-    slots: {
-        name?: string;
-        isObjectBindingPattern?: boolean;
-        define?: ReturnType<(node: ts.CallExpression) => TextRange & {
-            exp: TextRange;
-            arg?: TextRange;
-            typeArg?: TextRange;
-        }> & {
-            statement: TextRange;
-        };
-    };
-    emits: {
-        name?: string;
-        define?: ReturnType<(node: ts.CallExpression) => TextRange & {
-            exp: TextRange;
-            arg?: TextRange;
-            typeArg?: TextRange;
-        }> & {
-            statement: TextRange;
-            hasUnionTypeArg?: boolean;
-        };
-    };
-    expose: {
-        name?: string;
-        define?: ReturnType<(node: ts.CallExpression) => TextRange & {
-            exp: TextRange;
-            arg?: TextRange;
-            typeArg?: TextRange;
-        }>;
-    };
-    options: {
-        name?: string;
-        inheritAttrs?: string;
-    };
-    cssModules: {
-        define: ReturnType<(node: ts.CallExpression) => TextRange & {
-            exp: TextRange;
-            arg?: TextRange;
-            typeArg?: TextRange;
-        }>;
-    }[];
-    defineProp: {
-        localName: TextRange | undefined;
-        name: TextRange | undefined;
-        type: TextRange | undefined;
-        modifierType?: TextRange | undefined;
-        runtimeType: TextRange | undefined;
-        defaultValue: TextRange | undefined;
-        required: boolean;
-        isModel?: boolean;
+    bindings: {
+        range: TextRange;
+        moduleName?: string;
+        isDefaultImport?: boolean;
+        isNamespace?: boolean;
     }[];
-    templateRefs: {
-        name?: string;
-        define: ReturnType<(node: ts.CallExpression) => TextRange & {
-            exp: TextRange;
-            arg?: TextRange;
-            typeArg?: TextRange;
-        }>;
-    }[];
-};
-export declare function parseBindingRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile): TextRange[];
-export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, sourceFile: ts.SourceFile): TextRange[];
-export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, sourceFile: ts.SourceFile): {
-    start: number;
-    end: number;
+    defineProp: DefineProp[];
+    defineProps: DefineProps | undefined;
+    withDefaults: WithDefaults | undefined;
+    defineEmits: DefineEmits | undefined;
+    defineSlots: DefineSlots | undefined;
+    defineExpose: CallExpressionRange | undefined;
+    defineOptions: DefineOptions | undefined;
+    useAttrs: CallExpressionRange[];
+    useCssModule: CallExpressionRange[];
+    useSlots: CallExpressionRange[];
+    useTemplateRef: UseTemplateRef[];
 };
-export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, sourceFile: ts.SourceFile): string;
+export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile): {
+    range: TextRange;
+    moduleName?: string;
+    isDefaultImport?: boolean;
+    isNamespace?: boolean;
+}[];
+export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, ast: ts.SourceFile): TextRange[];
+export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): TextRange;
+export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;
+export {};