vue-component-meta 0.39.4 → 0.40.1

package/out/index.d.ts

@@ -1,6 +1,12 @@
+import * as ts from 'typescript/lib/tsserverlibrary';
 import type { MetaCheckerOptions, ComponentMeta, EventMeta, ExposeMeta, MetaCheckerSchemaOptions, PropertyMeta, PropertyMetaSchema, SlotMeta } from './types';
 export type { MetaCheckerOptions, ComponentMeta, EventMeta, ExposeMeta, MetaCheckerSchemaOptions, PropertyMeta, PropertyMetaSchema, SlotMeta };
 export declare function createComponentMetaChecker(tsconfigPath: string, checkerOptions?: MetaCheckerOptions): {
     getExportNames: (componentPath: string) => string[];
     getComponentMeta: (componentPath: string, exportName?: string) => ComponentMeta;
+    __internal__: {
+        program: ts.Program;
+        tsLs: ts.LanguageService;
+        typeChecker: ts.TypeChecker;
+    };
 };

package/out/index.js

@@ -1,10 +1,10 @@
-"use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createComponentMetaChecker = void 0;
 const vue = require("@volar/vue-language-core");
+const vue_language_core_1 = require("@volar/vue-language-core");
 const ts = require("typescript/lib/tsserverlibrary");
 function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
-    const parsedCommandLine = vue.tsShared.createParsedCommandLine(ts, {
+    const parsedCommandLine = vue.createParsedCommandLine(ts, {
         useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
         readDirectory: (path, extensions, exclude, include, depth) => {
             return ts.sys.readDirectory(path, [...extensions, '.vue'], exclude, include, depth);
@@ -70,6 +70,11 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
     return {
         getExportNames,
         getComponentMeta,
+        __internal__: {
+            program,
+            tsLs,
+            typeChecker,
+        },
     };
     function getMetaFileName(fileName) {
         return (fileName.endsWith('.vue') ? fileName : fileName.substring(0, fileName.lastIndexOf('.'))) + '.meta.ts';
@@ -77,7 +82,7 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
     function getMetaScriptContent(fileName) {
         return `
 			import * as Components from '${fileName.substring(0, fileName.length - '.meta.ts'.length)}';
-			export default {} as { [K in keyof typeof Components]: InstanceType<typeof Components[K]>; };;
+			export default {} as { [K in keyof typeof Components]: InstanceType<typeof Components[K]>; };
 		`;
     }
     function getExportNames(componentPath) {
@@ -92,7 +97,6 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
         }
         const componentType = typeChecker.getTypeOfSymbolAtLocation(_export, symbolNode);
         const symbolProperties = (_a = componentType.getProperties()) !== null && _a !== void 0 ? _a : [];
-        const { resolveNestedProperties, resolveEventSignature, resolveExposedProperties, resolveSlotProperties, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions.schema);
         return {
             props: getProps(),
             events: getEvents(),
@@ -105,9 +109,12 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
             let result = [];
             if ($props) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($props, symbolNode);
-                const properties = type.getApparentProperties();
+                const properties = type.getProperties();
                 result = properties
-                    .map(resolveNestedProperties)
+                    .map((prop) => {
+                    const { resolveNestedProperties, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions);
+                    return resolveNestedProperties(prop);
+                })
                     .filter((prop) => !prop.name.match(propEventRegex));
             }
             // fill global
@@ -115,15 +122,23 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
                 prop.global = globalPropNames.includes(prop.name);
             }
             // fill defaults
-            const printer = ts.createPrinter(checkerOptions.printer);
+            const printer = checkerOptions.printer ? ts.createPrinter(checkerOptions.printer) : undefined;
             const snapshot = host.getScriptSnapshot(componentPath);
-            const vueDefaults = componentPath.endsWith('.vue') && exportName === 'default' ? readVueComponentDefaultProps(snapshot.getText(0, snapshot.getLength()), printer) : {};
+            const vueDefaults = componentPath.endsWith('.vue') && exportName === 'default'
+                ? readVueComponentDefaultProps(core, snapshot.getText(0, snapshot.getLength()), printer)
+                : {};
             const tsDefaults = !componentPath.endsWith('.vue') ? readTsComponentDefaultProps(componentPath.substring(componentPath.lastIndexOf('.') + 1), // ts | js | tsx | jsx
             snapshot.getText(0, snapshot.getLength()), exportName, printer) : {};
             for (const [propName, defaultExp] of Object.entries(Object.assign(Object.assign({}, vueDefaults), tsDefaults))) {
                 const prop = result.find(p => p.name === propName);
                 if (prop) {
-                    prop.default = defaultExp;
+                    prop.default = defaultExp.default;
+                    if (defaultExp.required !== undefined) {
+                        prop.required = defaultExp.required;
+                    }
+                    if (prop.default !== undefined) {
+                        prop.required = false; // props with default are always optional
+                    }
                 }
             }
             return result;
@@ -133,7 +148,10 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
             if ($emit) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($emit, symbolNode);
                 const calls = type.getCallSignatures();
-                return calls.map(resolveEventSignature).filter(event => event.name);
+                return calls.map((call) => {
+                    const { resolveEventSignature, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions);
+                    return resolveEventSignature(call);
+                }).filter(event => event.name);
             }
             return [];
         }
@@ -144,7 +162,10 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
             if ($slots) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($slots, symbolNode);
                 const properties = type.getProperties();
-                return properties.map(resolveSlotProperties);
+                return properties.map((prop) => {
+                    const { resolveSlotProperties, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions);
+                    return resolveSlotProperties(prop);
+                });
             }
             return [];
         }
@@ -153,7 +174,10 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
             // only exposed props will have a syntheticOrigin
             Boolean(prop.syntheticOrigin));
             if (exposed.length) {
-                return exposed.map(resolveExposedProperties);
+                return exposed.map((prop) => {
+                    const { resolveExposedProperties, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions);
+                    return resolveExposedProperties(prop);
+                });
             }
             return [];
         }
@@ -188,10 +212,10 @@ function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
     }
 }
 exports.createComponentMetaChecker = createComponentMetaChecker;
-function createSchemaResolvers(typeChecker, symbolNode, options = false) {
+function createSchemaResolvers(typeChecker, symbolNode, { rawType, schema: options }) {
     var _a;
     const enabled = !!options;
-    const ignore = typeof options === 'object' ? (_a = options.ignore) !== null && _a !== void 0 ? _a : [] : [];
+    const ignore = typeof options === 'object' ? [...(_a = options === null || options === void 0 ? void 0 : options.ignore) !== null && _a !== void 0 ? _a : []] : [];
     function shouldIgnore(subtype) {
         const type = typeChecker.typeToString(subtype);
         if (type === 'any') {
@@ -202,6 +226,10 @@ function createSchemaResolvers(typeChecker, symbolNode, options = false) {
         }
         return ignore.includes(type);
     }
+    function setVisited(subtype) {
+        const type = typeChecker.typeToString(subtype);
+        ignore.push(type);
+    }
     function reducer(acc, cur) {
         acc[cur.name] = cur;
         return acc;
@@ -223,6 +251,7 @@ function createSchemaResolvers(typeChecker, symbolNode, options = false) {
             }),
             required: !Boolean((_c = (_b = (_a = prop.declarations) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.questionToken) !== null && _c !== void 0 ? _c : false),
             type: typeChecker.typeToString(subtype),
+            rawType: rawType ? subtype : undefined,
             schema,
         };
     }
@@ -232,6 +261,7 @@ function createSchemaResolvers(typeChecker, symbolNode, options = false) {
         return {
             name: prop.getName(),
             type: typeChecker.typeToString(subtype),
+            rawType: rawType ? subtype : undefined,
             description: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
             schema,
         };
@@ -242,6 +272,7 @@ function createSchemaResolvers(typeChecker, symbolNode, options = false) {
         return {
             name: expose.getName(),
             type: typeChecker.typeToString(subtype),
+            rawType: rawType ? subtype : undefined,
             description: ts.displayPartsToString(expose.getDocumentationComment(typeChecker)),
             schema,
         };
@@ -254,6 +285,7 @@ function createSchemaResolvers(typeChecker, symbolNode, options = false) {
         return {
             name: typeChecker.getTypeOfSymbolAtLocation(call.parameters[0], symbolNode).value,
             type: typeChecker.typeToString(subtype),
+            rawType: rawType ? subtype : undefined,
             signature: typeChecker.signatureToString(call),
             schema,
         };
@@ -270,69 +302,60 @@ function createSchemaResolvers(typeChecker, symbolNode, options = false) {
             schema,
         };
     }
-    function resolveEventSchema(subtype) {
-        return (subtype.getCallSignatures().length === 1)
-            ? resolveCallbackSchema(subtype.getCallSignatures()[0])
-            : typeChecker.typeToString(subtype);
-    }
-    function resolveNestedSchema(subtype) {
-        if (subtype.getCallSignatures().length === 0 &&
-            (subtype.isClassOrInterface() || subtype.isIntersection() || subtype.objectFlags & ts.ObjectFlags.Anonymous)) {
-            if (shouldIgnore(subtype)) {
-                return typeChecker.typeToString(subtype);
-            }
-            return {
-                kind: 'object',
-                type: typeChecker.typeToString(subtype),
-                schema: subtype.getProperties().map(resolveNestedProperties).reduce(reducer, {})
+    function resolveSchema(subtype) {
+        const type = typeChecker.typeToString(subtype);
+        let schema = type;
+        if (shouldIgnore(subtype)) {
+            return type;
+        }
+        setVisited(subtype);
+        if (subtype.isUnion()) {
+            schema = {
+                kind: 'enum',
+                type,
+                schema: subtype.types.map(resolveSchema)
             };
         }
-        return resolveEventSchema(subtype);
-    }
-    function resolveArraySchema(subtype) {
         // @ts-ignore - typescript internal, isArrayLikeType exists
-        if (typeChecker.isArrayLikeType(subtype)) {
-            if (shouldIgnore(subtype)) {
-                return typeChecker.typeToString(subtype);
-            }
-            return {
+        else if (typeChecker.isArrayLikeType(subtype)) {
+            schema = {
                 kind: 'array',
-                type: typeChecker.typeToString(subtype),
+                type,
                 schema: typeChecker.getTypeArguments(subtype).map(resolveSchema)
             };
         }
-        return resolveNestedSchema(subtype);
-    }
-    function resolveSchema(subtype) {
-        return subtype.isUnion()
-            ? {
-                kind: 'enum',
-                type: typeChecker.typeToString(subtype),
-                schema: subtype.types.map(resolveArraySchema)
-            }
-            : resolveArraySchema(subtype);
+        else if (subtype.getCallSignatures().length === 0 &&
+            (subtype.isClassOrInterface() || subtype.isIntersection() || subtype.objectFlags & ts.ObjectFlags.Anonymous)) {
+            // setVisited(subtype);
+            schema = {
+                kind: 'object',
+                type,
+                schema: subtype.getProperties().map(resolveNestedProperties).reduce(reducer, {})
+            };
+        }
+        else if (subtype.getCallSignatures().length === 1) {
+            schema = resolveCallbackSchema(subtype.getCallSignatures()[0]);
+        }
+        return schema;
     }
     return {
         resolveNestedProperties,
         resolveSlotProperties,
         resolveEventSignature,
         resolveExposedProperties,
-        resolveCallbackSchema,
-        resolveEventSchema,
-        resolveNestedSchema,
-        resolveArraySchema,
         resolveSchema,
     };
 }
-function readVueComponentDefaultProps(vueFileText, printer) {
-    const result = {};
+function readVueComponentDefaultProps(core, vueFileText, printer) {
+    let result = {};
     scriptSetupWorker();
-    sciptWorker();
+    scriptWorker();
     return result;
     function scriptSetupWorker() {
-        const vueSourceFile = vue.createSourceFile('/tmp.vue', vueFileText, {}, {}, ts);
-        const descriptor = vueSourceFile.getDescriptor();
-        const scriptSetupRanges = vueSourceFile.getScriptSetupRanges();
+        var _a;
+        const vueSourceFile = vue.createSourceFile('/tmp.vue', vueFileText, {}, ts, core.plugins);
+        const descriptor = vueSourceFile.sfc;
+        const scriptSetupRanges = descriptor.scriptSetupAst ? (0, vue_language_core_1.parseScriptSetupRanges)(ts, descriptor.scriptSetupAst) : undefined;
         if (descriptor.scriptSetup && (scriptSetupRanges === null || scriptSetupRanges === void 0 ? void 0 : scriptSetupRanges.withDefaultsArg)) {
             const defaultsText = descriptor.scriptSetup.content.substring(scriptSetupRanges.withDefaultsArg.start, scriptSetupRanges.withDefaultsArg.end);
             const ast = ts.createSourceFile('/tmp.' + descriptor.scriptSetup.lang, '(' + defaultsText + ')', ts.ScriptTarget.Latest);
@@ -341,29 +364,39 @@ function readVueComponentDefaultProps(vueFileText, printer) {
                 for (const prop of obj.properties) {
                     if (ts.isPropertyAssignment(prop)) {
                         const name = prop.name.getText(ast);
-                        const exp = printer.printNode(ts.EmitHint.Expression, resolveDefaultOptionExpression(prop.initializer), ast);
-                        ;
-                        result[name] = exp;
+                        const expNode = resolveDefaultOptionExpression(prop.initializer);
+                        const expText = (_a = printer === null || printer === void 0 ? void 0 : printer.printNode(ts.EmitHint.Expression, expNode, ast)) !== null && _a !== void 0 ? _a : expNode.getText(ast);
+                        result[name] = {
+                            default: expText,
+                        };
                     }
                 }
             }
-            function findObjectLiteralExpression(node) {
-                if (ts.isObjectLiteralExpression(node)) {
-                    return node;
-                }
-                let result;
-                node.forEachChild(child => {
-                    if (!result) {
-                        result = findObjectLiteralExpression(child);
-                    }
-                });
-                return result;
+        }
+        else if (descriptor.scriptSetup && (scriptSetupRanges === null || scriptSetupRanges === void 0 ? void 0 : scriptSetupRanges.propsRuntimeArg)) {
+            const defaultsText = descriptor.scriptSetup.content.substring(scriptSetupRanges.propsRuntimeArg.start, scriptSetupRanges.propsRuntimeArg.end);
+            const ast = ts.createSourceFile('/tmp.' + descriptor.scriptSetup.lang, '(' + defaultsText + ')', ts.ScriptTarget.Latest);
+            const obj = findObjectLiteralExpression(ast);
+            if (obj) {
+                result = Object.assign(Object.assign({}, result), resolvePropsOption(ast, obj, printer));
             }
         }
+        function findObjectLiteralExpression(node) {
+            if (ts.isObjectLiteralExpression(node)) {
+                return node;
+            }
+            let result;
+            node.forEachChild(child => {
+                if (!result) {
+                    result = findObjectLiteralExpression(child);
+                }
+            });
+            return result;
+        }
     }
-    function sciptWorker() {
-        const vueSourceFile = vue.createSourceFile('/tmp.vue', vueFileText, {}, {}, ts);
-        const descriptor = vueSourceFile.getDescriptor();
+    function scriptWorker() {
+        const vueSourceFile = vue.createSourceFile('/tmp.vue', vueFileText, {}, ts, core.plugins);
+        const descriptor = vueSourceFile.sfc;
         if (descriptor.script) {
             const scriptResult = readTsComponentDefaultProps(descriptor.script.lang, descriptor.script.content, 'default', printer);
             for (const [key, value] of Object.entries(scriptResult)) {
@@ -373,28 +406,12 @@ function readVueComponentDefaultProps(vueFileText, printer) {
     }
 }
 function readTsComponentDefaultProps(lang, tsFileText, exportName, printer) {
-    var _a, _b;
-    const result = {};
     const ast = ts.createSourceFile('/tmp.' + lang, tsFileText, ts.ScriptTarget.Latest);
     const props = getPropsNode();
     if (props) {
-        for (const prop of props.properties) {
-            if (ts.isPropertyAssignment(prop)) {
-                const name = (_a = prop.name) === null || _a === void 0 ? void 0 : _a.getText(ast);
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
-                    for (const propOption of prop.initializer.properties) {
-                        if (ts.isPropertyAssignment(propOption)) {
-                            if (((_b = propOption.name) === null || _b === void 0 ? void 0 : _b.getText(ast)) === 'default') {
-                                const _default = propOption.initializer;
-                                result[name] = printer.printNode(ts.EmitHint.Expression, resolveDefaultOptionExpression(_default), ast);
-                            }
-                        }
-                    }
-                }
-            }
-        }
+        return resolvePropsOption(ast, props, printer);
     }
-    return result;
+    return {};
     function getComponentNode() {
         let result;
         if (exportName === 'default') {
@@ -448,6 +465,30 @@ function readTsComponentDefaultProps(lang, tsFileText, exportName, printer) {
         }
     }
 }
+function resolvePropsOption(ast, props, printer) {
+    var _a, _b;
+    const result = {};
+    for (const prop of props.properties) {
+        if (ts.isPropertyAssignment(prop)) {
+            const name = (_a = prop.name) === null || _a === void 0 ? void 0 : _a.getText(ast);
+            if (ts.isObjectLiteralExpression(prop.initializer)) {
+                const defaultProp = prop.initializer.properties.find(p => ts.isPropertyAssignment(p) && p.name.getText(ast) === 'default');
+                const requiredProp = prop.initializer.properties.find(p => ts.isPropertyAssignment(p) && p.name.getText(ast) === 'required');
+                result[name] = {};
+                if (requiredProp) {
+                    const exp = requiredProp.initializer.getText(ast);
+                    result[name].required = exp === 'true';
+                }
+                if (defaultProp) {
+                    const expNode = resolveDefaultOptionExpression(defaultProp.initializer);
+                    const expText = (_b = printer === null || printer === void 0 ? void 0 : printer.printNode(ts.EmitHint.Expression, expNode, ast)) !== null && _b !== void 0 ? _b : expNode.getText(ast);
+                    result[name].default = expText;
+                }
+            }
+        }
+    }
+    return result;
+}
 function resolveDefaultOptionExpression(_default) {
     if (ts.isArrowFunction(_default)) {
         if (ts.isBlock(_default.body)) {

package/out/types.d.ts

@@ -11,6 +11,7 @@ export interface PropertyMeta {
     global: boolean;
     required: boolean;
     type: string;
+    rawType?: ts.Type;
     tags: {
         name: string;
         text?: string;
@@ -20,12 +21,14 @@ export interface PropertyMeta {
 export interface EventMeta {
     name: string;
     type: string;
+    rawType?: ts.Type;
     signature: string;
     schema?: PropertyMetaSchema[];
 }
 export interface SlotMeta {
     name: string;
     type: string;
+    rawType?: ts.Type;
     description: string;
     schema?: PropertyMetaSchema;
 }
@@ -33,6 +36,7 @@ export interface ExposeMeta {
     name: string;
     description: string;
     type: string;
+    rawType?: ts.Type;
     schema?: PropertyMetaSchema;
 }
 export declare type PropertyMetaSchema = string | {
@@ -59,4 +63,5 @@ export interface MetaCheckerOptions {
     schema?: MetaCheckerSchemaOptions;
     forceUseTs?: boolean;
     printer?: import('typescript').PrinterOptions;
+    rawType?: boolean;
 }

package/out/types.js

@@ -1,4 +1,3 @@
-"use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 ;
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "vue-component-meta",
-	"version": "0.39.4",
+	"version": "0.40.1",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -13,10 +13,10 @@
 		"directory": "packages/vue-component-meta"
 	},
 	"dependencies": {
-		"@volar/vue-language-core": "0.39.4"
+		"@volar/vue-language-core": "0.40.1"
 	},
 	"peerDependencies": {
 		"typescript": "*"
 	},
-	"gitHead": "e3f6327b11a0a41c1b448c2ecc25ba85b9986dee"
+	"gitHead": "4f92ef83a905c6d46cc92653ad87e0aec10f4e53"
 }