@vue/language-core 3.1.8 → 3.2.0

package/lib/languagePlugin.js

@@ -1,10 +1,43 @@
 "use strict";
 /// <reference types="@volar/typescript" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVueLanguagePlugin = createVueLanguagePlugin;
 exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
-const CompilerDOM = require("@vue/compiler-dom");
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const plugins_1 = require("./plugins");
 const virtualCode_1 = require("./virtualCode");
 const fileRegistries = {};

package/lib/parsers/scriptRanges.d.ts

@@ -2,22 +2,32 @@ import type * as ts from 'typescript';
 import type { TextRange, VueCompilerOptions } from '../types';
 export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 }
-export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
-    exportDefault: (TextRange & {
-        expression: TextRange;
+export declare function parseScriptRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+    exportDefault: (TextRange<ts.Node> & {
+        expression: TextRange<ts.Expression>;
         isObjectLiteral: boolean;
+        options?: {
+            isObjectLiteral: boolean;
+            expression: TextRange<ts.Node>;
+            args: TextRange<ts.ObjectLiteralExpression>;
+            components: TextRange<ts.ObjectLiteralExpression> | undefined;
+            directives: TextRange<ts.Node> | undefined;
+            name: TextRange<ts.StringLiteral> | undefined;
+            inheritAttrs: string | undefined;
+        } | undefined;
     }) | undefined;
-    componentOptions: {
-        isObjectLiteral: boolean;
-        expression: TextRange;
-        args: TextRange;
-        argsNode: ts.ObjectLiteralExpression;
-        components: TextRange | undefined;
-        componentsNode: ts.ObjectLiteralExpression | undefined;
-        directives: TextRange | undefined;
-        name: TextRange | undefined;
-        inheritAttrs: string | undefined;
-    } | undefined;
-    bindings: TextRange[];
-    components: TextRange[];
+    bindings: TextRange<ts.Node>[];
+    components: TextRange<ts.Node>[];
 };
+export declare function parseOptionsFromExtression(ts: typeof import('typescript'), exp: ts.Node, sourceFile: ts.SourceFile): {
+    isObjectLiteral: boolean;
+    expression: TextRange<ts.Node>;
+    args: TextRange<ts.ObjectLiteralExpression>;
+    argsNode: ts.ObjectLiteralExpression;
+    components: TextRange<ts.ObjectLiteralExpression> | undefined;
+    componentsNode: ts.ObjectLiteralExpression | undefined;
+    directives: TextRange<ts.ObjectLiteralExpression> | undefined;
+    name: TextRange<ts.StringLiteral> | undefined;
+    nameNode: ts.StringLiteral | undefined;
+    inheritAttrs: string | undefined;
+} | undefined;

package/lib/parsers/scriptRanges.js

@@ -1,88 +1,90 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptRanges = parseScriptRanges;
+exports.parseOptionsFromExtression = parseOptionsFromExtression;
 const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
-function parseScriptRanges(ts, ast, vueCompilerOptions) {
+function parseScriptRanges(ts, sourceFile, vueCompilerOptions) {
     let exportDefault;
-    let componentOptions;
-    const { bindings, components } = (0, utils_1.parseBindingRanges)(ts, ast, vueCompilerOptions.extensions);
-    ts.forEachChild(ast, raw => {
-        if (ts.isExportAssignment(raw)) {
+    const { bindings, components } = (0, utils_1.parseBindingRanges)(ts, sourceFile, vueCompilerOptions.extensions);
+    ts.forEachChild(sourceFile, child => {
+        if (ts.isExportAssignment(child)) {
             exportDefault = {
-                ..._getStartEnd(raw),
-                expression: _getStartEnd(raw.expression),
-                isObjectLiteral: ts.isObjectLiteralExpression(raw.expression),
+                ...(0, shared_1.getStartEnd)(ts, child, sourceFile),
+                expression: (0, shared_1.getStartEnd)(ts, child.expression, sourceFile),
+                isObjectLiteral: ts.isObjectLiteralExpression(child.expression),
+                options: parseOptionsFromExtression(ts, child.expression, sourceFile),
             };
-            const comment = (0, utils_1.getClosestMultiLineCommentRange)(ts, raw, [], ast);
+            const comment = (0, utils_1.getClosestMultiLineCommentRange)(ts, child, [], sourceFile);
             if (comment) {
                 exportDefault.start = comment.start;
             }
-            let node = raw;
-            while (isAsExpression(node.expression) || ts.isParenthesizedExpression(node.expression)) { // fix https://github.com/vuejs/language-tools/issues/1882
-                node = node.expression;
-            }
-            let obj;
-            if (ts.isObjectLiteralExpression(node.expression)) {
-                obj = node.expression;
-            }
-            else if (ts.isCallExpression(node.expression) && node.expression.arguments.length) {
-                const arg0 = node.expression.arguments[0];
-                if (ts.isObjectLiteralExpression(arg0)) {
-                    obj = arg0;
-                }
-            }
-            if (obj) {
-                let componentsOptionNode;
-                let directivesOptionNode;
-                let nameOptionNode;
-                let inheritAttrsOption;
-                ts.forEachChild(obj, node => {
-                    if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
-                        const name = _getNodeText(node.name);
-                        if (name === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
-                            componentsOptionNode = node.initializer;
-                        }
-                        else if (name === 'directives' && ts.isObjectLiteralExpression(node.initializer)) {
-                            directivesOptionNode = node.initializer;
-                        }
-                        else if (name === 'name') {
-                            nameOptionNode = node.initializer;
-                        }
-                        else if (name === 'inheritAttrs') {
-                            inheritAttrsOption = _getNodeText(node.initializer);
-                        }
-                    }
-                });
-                componentOptions = {
-                    isObjectLiteral: ts.isObjectLiteralExpression(node.expression),
-                    expression: _getStartEnd(node.expression),
-                    args: _getStartEnd(obj),
-                    argsNode: obj,
-                    components: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
-                    componentsNode: componentsOptionNode,
-                    directives: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
-                    name: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
-                    inheritAttrs: inheritAttrsOption,
-                };
-            }
         }
     });
     return {
         exportDefault,
-        componentOptions,
         bindings,
         components,
     };
+}
+function parseOptionsFromExtression(ts, exp, sourceFile) {
+    let obj;
+    while (isAsExpression(ts, exp) || ts.isParenthesizedExpression(exp)) { // fix https://github.com/vuejs/language-tools/issues/1882
+        exp = exp.expression;
+    }
+    if (ts.isObjectLiteralExpression(exp)) {
+        obj = exp;
+    }
+    else if (ts.isCallExpression(exp) && exp.arguments.length) {
+        const arg0 = exp.arguments[0];
+        if (ts.isObjectLiteralExpression(arg0)) {
+            obj = arg0;
+        }
+    }
+    if (obj) {
+        let componentsOptionNode;
+        let directivesOptionNode;
+        let nameOptionNode;
+        let inheritAttrsOption;
+        ts.forEachChild(obj, node => {
+            if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+                const name = _getNodeText(node.name);
+                if (name === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
+                    componentsOptionNode = node.initializer;
+                }
+                else if (name === 'directives' && ts.isObjectLiteralExpression(node.initializer)) {
+                    directivesOptionNode = node.initializer;
+                }
+                else if (name === 'name' && ts.isStringLiteral(node.initializer)) {
+                    nameOptionNode = node.initializer;
+                }
+                else if (name === 'inheritAttrs') {
+                    inheritAttrsOption = _getNodeText(node.initializer);
+                }
+            }
+        });
+        return {
+            isObjectLiteral: ts.isObjectLiteralExpression(exp),
+            expression: _getStartEnd(exp),
+            args: _getStartEnd(obj),
+            argsNode: obj,
+            components: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
+            componentsNode: componentsOptionNode,
+            directives: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
+            name: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
+            nameNode: nameOptionNode,
+            inheritAttrs: inheritAttrsOption,
+        };
+    }
     function _getStartEnd(node) {
-        return (0, shared_1.getStartEnd)(ts, node, ast);
+        return (0, shared_1.getStartEnd)(ts, node, sourceFile);
     }
     function _getNodeText(node) {
-        return (0, shared_1.getNodeText)(ts, node, ast);
-    }
-    // isAsExpression is missing in tsc
-    function isAsExpression(node) {
-        return node.kind === ts.SyntaxKind.AsExpression;
+        return (0, shared_1.getNodeText)(ts, node, sourceFile);
     }
 }
+// isAsExpression is missing in tsc
+function isAsExpression(ts, node) {
+    return node.kind === ts.SyntaxKind.AsExpression;
+}
 //# sourceMappingURL=scriptRanges.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -1,12 +1,13 @@
 import type * as ts from 'typescript';
 import type { TextRange, VueCompilerOptions } from '../types';
-type CallExpressionRange = {
+export interface CallExpressionRange {
     callExp: TextRange;
     exp: TextRange;
     arg?: TextRange;
     typeArg?: TextRange;
-};
-type DefineModel = {
+}
+export interface DefineModel {
+    arg?: TextRange;
     localName?: TextRange;
     name?: TextRange;
     type?: TextRange;
@@ -15,44 +16,39 @@ type DefineModel = {
     defaultValue?: TextRange;
     required?: boolean;
     comments?: TextRange;
-    argNode?: ts.Expression;
-};
-type DefineProps = CallExpressionRange & {
+}
+export interface DefineProps extends CallExpressionRange {
     name?: string;
     destructured?: Map<string, ts.Expression | undefined>;
     destructuredRest?: string;
     statement: TextRange;
-    argNode?: ts.Expression;
-};
-type WithDefaults = Omit<CallExpressionRange, 'typeArg'> & {
-    argNode?: ts.Expression;
-};
-type DefineEmits = CallExpressionRange & {
+}
+export interface DefineEmits extends CallExpressionRange {
     name?: string;
     hasUnionTypeArg?: boolean;
     statement: TextRange;
-};
-type DefineSlots = CallExpressionRange & {
+}
+export interface DefineSlots extends CallExpressionRange {
     name?: string;
     statement: TextRange;
-};
-type DefineOptions = {
+}
+export interface DefineOptions {
     name?: string;
     inheritAttrs?: string;
-};
-type UseTemplateRef = CallExpressionRange & {
+}
+export interface UseTemplateRef extends CallExpressionRange {
     name?: string;
-};
+}
 export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
 }
-export declare function parseScriptSetupRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+export declare function parseScriptSetupRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
     leadingCommentEndOffset: number;
     importSectionEndOffset: number;
-    bindings: TextRange[];
-    components: TextRange[];
+    bindings: TextRange<ts.Node>[];
+    components: TextRange<ts.Node>[];
     defineModel: DefineModel[];
     defineProps: DefineProps | undefined;
-    withDefaults: WithDefaults | undefined;
+    withDefaults: CallExpressionRange | undefined;
     defineEmits: DefineEmits | undefined;
     defineSlots: DefineSlots | undefined;
     defineExpose: CallExpressionRange | undefined;
@@ -62,4 +58,3 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     useSlots: CallExpressionRange[];
     useTemplateRef: UseTemplateRef[];
 };
-export {};

package/lib/parsers/scriptSetupRanges.js

@@ -5,7 +5,7 @@ const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
 const tsCheckReg = /^\/\/\s*@ts-(?:no)?check(?:$|\s)/;
-function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
+function parseScriptSetupRanges(ts, sourceFile, vueCompilerOptions) {
     const defineModel = [];
     let defineProps;
     let withDefaults;
@@ -17,13 +17,13 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const useCssModule = [];
     const useSlots = [];
     const useTemplateRef = [];
-    const text = ast.text;
+    const text = sourceFile.text;
     const leadingCommentRanges = ts.getLeadingCommentRanges(text, 0)?.reverse() ?? [];
     const leadingCommentEndOffset = leadingCommentRanges.find(range => tsCheckReg.test(text.slice(range.pos, range.end)))?.end ?? 0;
-    let { bindings, components } = (0, utils_1.parseBindingRanges)(ts, ast, vueCompilerOptions.extensions);
+    let { bindings, components } = (0, utils_1.parseBindingRanges)(ts, sourceFile, vueCompilerOptions.extensions);
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
-    ts.forEachChild(ast, node => {
+    ts.forEachChild(sourceFile, node => {
         if (foundNonImportExportNode
             || ts.isImportDeclaration(node)
             || ts.isExportDeclaration(node)
@@ -42,11 +42,11 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             importSectionEndOffset = commentRange.pos;
         }
         else {
-            importSectionEndOffset = (0, shared_1.getStartEnd)(ts, node, ast).start;
+            importSectionEndOffset = (0, shared_1.getStartEnd)(ts, node, sourceFile).start;
         }
         foundNonImportExportNode = true;
     });
-    ts.forEachChild(ast, node => visitNode(node, [ast]));
+    ts.forEachChild(sourceFile, node => visitNode(node, [sourceFile]));
     const templateRefNames = new Set(useTemplateRef.map(ref => ref.name));
     bindings = bindings.filter(range => {
         const name = text.slice(range.start, range.end);
@@ -135,15 +135,14 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     runtimeType,
                     defaultValue,
                     required,
-                    comments: (0, utils_1.getClosestMultiLineCommentRange)(ts, node, parents, ast),
-                    argNode: options,
+                    comments: (0, utils_1.getClosestMultiLineCommentRange)(ts, node, parents, sourceFile),
+                    arg: _getStartEnd(node),
                 });
             }
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
                 defineProps = {
                     ...parseCallExpressionAssignment(node, parent),
-                    statement: getStatementRange(ts, parents, node, ast),
-                    argNode: node.arguments[0],
+                    statement: getStatementRange(ts, parents, node, sourceFile),
                 };
                 if (ts.isVariableDeclaration(parent) && ts.isObjectBindingPattern(parent.name)) {
                     defineProps.destructured = new Map();
@@ -172,13 +171,12 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     callExp: _getStartEnd(node),
                     exp: _getStartEnd(node.expression),
                     arg: arg ? _getStartEnd(arg) : undefined,
-                    argNode: arg,
                 };
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
                 defineEmits = {
                     ...parseCallExpressionAssignment(node, parent),
-                    statement: getStatementRange(ts, parents, node, ast),
+                    statement: getStatementRange(ts, parents, node, sourceFile),
                 };
                 if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0])) {
                     for (const member of node.typeArguments[0].members) {
@@ -195,7 +193,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
                 defineSlots = {
                     ...parseCallExpressionAssignment(node, parent),
-                    statement: getStatementRange(ts, parents, node, ast),
+                    statement: getStatementRange(ts, parents, node, sourceFile),
                 };
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
@@ -258,10 +256,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         };
     }
     function _getStartEnd(node) {
-        return (0, shared_1.getStartEnd)(ts, node, ast);
+        return (0, shared_1.getStartEnd)(ts, node, sourceFile);
     }
     function _getNodeText(node) {
-        return (0, shared_1.getNodeText)(ts, node, ast);
+        return (0, shared_1.getNodeText)(ts, node, sourceFile);
     }
 }
 function getStatementRange(ts, parents, node, ast) {

package/lib/parsers/utils.d.ts

@@ -1,10 +1,7 @@
 import type * as ts from 'typescript';
 import type { TextRange } from '../types';
 export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile, componentExtsensions: string[]): {
-    bindings: TextRange[];
-    components: TextRange[];
+    bindings: TextRange<ts.Node>[];
+    components: TextRange<ts.Node>[];
 };
-export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): {
-    start: number;
-    end: number;
-} | undefined;
+export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): TextRange | undefined;

package/lib/parsers/utils.js

@@ -85,6 +85,7 @@ function getClosestMultiLineCommentRange(ts, node, parents, ast) {
         .find(range => range.kind === 3);
     if (comment) {
         return {
+            node,
             start: comment.pos,
             end: comment.end,
         };

package/lib/plugins/vue-template-inline-css.js

@@ -1,6 +1,39 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const CompilerDOM = require("@vue/compiler-dom");
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const forEachTemplateNode_1 = require("../utils/forEachTemplateNode");
 const shared_1 = require("../utils/shared");
 const shared_2 = require("./shared");

package/lib/plugins/vue-template-inline-ts.js

@@ -1,6 +1,39 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const CompilerDOM = require("@vue/compiler-dom");
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const elementEvents_1 = require("../codegen/template/elementEvents");
 const templateChild_1 = require("../codegen/template/templateChild");
 const vFor_1 = require("../codegen/template/vFor");