@vue/language-core 2.1.10 → 2.2.2

package/lib/codegen/template/context.js

@@ -1,115 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTemplateCodegenContext = createTemplateCodegenContext;
-const common_1 = require("../common");
-const _codeFeatures = {
-    all: {
-        verification: true,
-        completion: true,
-        semantic: true,
-        navigation: true,
-    },
-    verification: {
-        verification: true,
-    },
-    completion: {
-        completion: true,
-    },
-    additionalCompletion: {
-        completion: { isAdditional: true },
-    },
-    navigation: {
-        navigation: true,
-    },
-    navigationWithoutRename: {
-        navigation: {
-            shouldRename() {
-                return false;
-            },
-        },
-    },
-    navigationAndCompletion: {
-        navigation: true,
-        completion: true,
-    },
-    navigationAndAdditionalCompletion: {
-        navigation: true,
-        completion: { isAdditional: true },
-    },
-    withoutHighlight: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-        navigation: true,
-        completion: true,
-    },
-    withoutHighlightAndCompletion: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-        navigation: true,
-    },
-    withoutHighlightAndCompletionAndNavigation: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-    },
-};
+const codeFeatures_1 = require("../codeFeatures");
+const utils_1 = require("../utils");
 function createTemplateCodegenContext(options) {
     let ignoredError = false;
     let expectErrorToken;
+    let lastGenericComment;
     let variableId = 0;
-    const codeFeatures = new Proxy(_codeFeatures, {
-        get(target, key) {
-            const data = target[key];
-            if (data.verification) {
-                if (ignoredError) {
-                    return {
-                        ...data,
-                        verification: false,
-                    };
-                }
-                if (expectErrorToken) {
-                    const token = expectErrorToken;
-                    if (typeof data.verification !== 'object' || !data.verification.shouldReport) {
-                        return {
-                            ...data,
-                            verification: {
-                                shouldReport: () => {
-                                    token.errors++;
-                                    return false;
-                                },
-                            },
-                        };
-                    }
-                }
+    function resolveCodeFeatures(features) {
+        if (features.verification) {
+            if (ignoredError) {
+                return {
+                    ...features,
+                    verification: false,
+                };
             }
-            return data;
-        },
-    });
+            if (expectErrorToken) {
+                const token = expectErrorToken;
+                return {
+                    ...features,
+                    verification: {
+                        shouldReport: () => {
+                            token.errors++;
+                            return false;
+                        },
+                    },
+                };
+            }
+        }
+        return features;
+    }
     const localVars = new Map();
+    const specialVars = new Set();
     const accessExternalVariables = new Map();
     const slots = [];
     const dynamicSlots = [];
-    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 {
+        codeFeatures: new Proxy(codeFeatures_1.codeFeatures, {
+            get(target, key) {
+                const data = target[key];
+                return resolveCodeFeatures(data);
+            },
+        }),
+        resolveCodeFeatures,
         slots,
         dynamicSlots,
-        codeFeatures,
+        specialVars,
         accessExternalVariables,
-        hasSlotElements,
+        lastGenericComment,
         blockConditions,
-        usedComponentCtxVars,
         scopedClasses,
         emptyClassOffsets,
         inlayHints,
         hasSlot: false,
-        inheritedAttrVars: new Set(),
+        bindingAttrLocs,
+        inheritedAttrVars,
         templateRefs,
+        currentComponent: undefined,
         singleRootElType: undefined,
         singleRootNode: undefined,
         accessExternalVariable(name, offset) {
@@ -136,7 +91,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 +100,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 +128,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) {
@@ -184,8 +139,8 @@ function createTemplateCodegenContext(options) {
                             'template',
                             offset,
                             {
-                                ...codeFeatures.additionalCompletion,
-                                ...codeFeatures.withoutHighlightAndCompletionAndNavigation,
+                                ...codeFeatures_1.codeFeatures.additionalCompletion,
+                                ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletionAndNavigation,
                             },
                         ];
                     }
@@ -194,14 +149,14 @@ function createTemplateCodegenContext(options) {
                             varName,
                             'template',
                             offset,
-                            codeFeatures.additionalCompletion,
+                            codeFeatures_1.codeFeatures.additionalCompletion,
                         ];
                     }
                     yield `,`;
                 }
                 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>;