vue-component-meta 0.39.2 → 0.39.5

package/out/index.d.ts

@@ -1,53 +1,12 @@
-export declare type PropertyMeta = {
-    name: string;
-    default?: string;
-    description: string;
-    required: boolean;
-    type: string;
-    tags: {
-        name: string;
-        text?: string;
-    }[];
-    schema: PropertyMetaSchema;
-};
-export declare type PropertyMetaSchema = string | {
-    kind: 'enum';
-    type: string;
-    schema: PropertyMetaSchema[];
-} | {
-    kind: 'array';
-    type: string;
-    schema: PropertyMetaSchema[];
-} | {
-    kind: 'event';
-    type: string;
-    schema: PropertyMetaSchema[];
-} | {
-    kind: 'object';
-    type: string;
-    schema: Record<string, PropertyMeta>;
-};
-export declare function createComponentMetaChecker(tsconfigPath: string): {
-    getGlobalPropNames: () => string[];
+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) => {
-        props: PropertyMeta[];
-        events: {
-            name: string;
-            type: string;
-            signature: string;
-            schema: PropertyMetaSchema[];
-        }[];
-        slots: {
-            name: string;
-            type: string;
-            description: string;
-        }[];
-        exposed: {
-            name: string;
-            type: string;
-            description: string;
-        }[];
+    getComponentMeta: (componentPath: string, exportName?: string) => ComponentMeta;
+    __internal__: {
+        program: ts.Program;
+        tsLs: ts.LanguageService;
+        typeChecker: ts.TypeChecker;
     };
 };
-export declare function findCmponentDefaultProps(componentPath: string): Record<string, string>;

package/out/index.js

@@ -1,83 +1,8 @@
-"use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findCmponentDefaultProps = exports.createComponentMetaChecker = void 0;
+exports.createComponentMetaChecker = void 0;
 const vue = require("@volar/vue-language-core");
 const ts = require("typescript/lib/tsserverlibrary");
-function createSchemaResolvers(typeChecker, symbolNode) {
-    function reducer(acc, cur) {
-        acc[cur.name] = cur;
-        return acc;
-    }
-    function resolveSymbolSchema(prop) {
-        var _a, _b, _c;
-        const subtype = typeChecker.getTypeOfSymbolAtLocation(prop, symbolNode);
-        typeChecker.getDefaultFromTypeParameter(subtype);
-        return {
-            name: prop.getEscapedName().toString(),
-            description: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
-            tags: prop.getJsDocTags(typeChecker).map(tag => {
-                var _a;
-                return ({
-                    name: tag.name,
-                    text: (_a = tag.text) === null || _a === void 0 ? void 0 : _a.map(part => part.text).join(''),
-                });
-            }),
-            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),
-            schema: resolveSchema(subtype),
-        };
-    }
-    function resolveCallbackSchema(signature) {
-        return {
-            kind: 'event',
-            type: typeChecker.signatureToString(signature),
-            schema: typeChecker.getTypeArguments(typeChecker.getTypeOfSymbolAtLocation(signature.parameters[0], symbolNode)).map(resolveSchema)
-        };
-    }
-    function resolveEventSchema(subtype) {
-        return (subtype.getCallSignatures().length === 1)
-            ? resolveCallbackSchema(subtype.getCallSignatures()[0])
-            : typeChecker.typeToString(subtype);
-    }
-    function resolveNestedSchema(subtype) {
-        // !!(subtype.flags & ts.TypeFlags.Object)
-        return (subtype.isClassOrInterface() || subtype.isIntersection())
-            ? {
-                kind: 'object',
-                type: typeChecker.typeToString(subtype),
-                schema: subtype.getProperties().map(resolveSymbolSchema).reduce(reducer, {})
-            }
-            : resolveEventSchema(subtype);
-    }
-    function resolveArraySchema(subtype) {
-        // @ts-ignore - typescript internal, isArrayLikeType exists
-        return typeChecker.isArrayLikeType(subtype)
-            ? {
-                kind: 'array',
-                type: typeChecker.typeToString(subtype),
-                schema: typeChecker.getTypeArguments(subtype).map(resolveSchema)
-            }
-            : resolveNestedSchema(subtype);
-    }
-    function resolveSchema(subtype) {
-        return subtype.isUnion()
-            ? {
-                kind: 'enum',
-                type: typeChecker.typeToString(subtype),
-                schema: subtype.types.map(resolveArraySchema)
-            }
-            : resolveArraySchema(subtype);
-    }
-    return {
-        resolveSymbolSchema,
-        resolveCallbackSchema,
-        resolveEventSchema,
-        resolveNestedSchema,
-        resolveArraySchema,
-        resolveSchema,
-    };
-}
-function createComponentMetaChecker(tsconfigPath) {
+function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
     const parsedCommandLine = vue.tsShared.createParsedCommandLine(ts, {
         useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
         readDirectory: (path, extensions, exclude, include, depth) => {
@@ -88,7 +13,7 @@ function createComponentMetaChecker(tsconfigPath) {
     }, tsconfigPath);
     const scriptSnapshot = {};
     const globalComponentName = tsconfigPath.replace(/\\/g, '/') + '.global.ts';
-    const core = vue.createLanguageContext(Object.assign(Object.assign({}, ts.sys), { getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options), useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames, getCompilationSettings: () => parsedCommandLine.options, getScriptFileNames: () => {
+    const host = Object.assign(Object.assign({}, ts.sys), { getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options), useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames, getCompilationSettings: () => parsedCommandLine.options, getScriptFileNames: () => {
             return [
                 ...parsedCommandLine.fileNames,
                 ...parsedCommandLine.fileNames.map(getMetaFileName),
@@ -115,39 +40,48 @@ function createComponentMetaChecker(tsconfigPath) {
                 }
             }
             return scriptSnapshot[fileName];
-        }, getTypeScriptModule: () => ts, getVueCompilationSettings: () => parsedCommandLine.vueOptions }));
-    const tsLs = ts.createLanguageService(core.typescriptLanguageServiceHost);
+        }, getTypeScriptModule: () => ts, getVueCompilationSettings: () => parsedCommandLine.vueOptions });
+    const core = vue.createLanguageContext(host);
+    const proxyApis = checkerOptions.forceUseTs ? {
+        getScriptKind: (fileName) => {
+            if (fileName.endsWith('.vue.js')) {
+                return ts.ScriptKind.TS;
+            }
+            if (fileName.endsWith('.vue.jsx')) {
+                return ts.ScriptKind.TSX;
+            }
+            return core.typescriptLanguageServiceHost.getScriptKind(fileName);
+        },
+    } : {};
+    const proxyHost = new Proxy(core.typescriptLanguageServiceHost, {
+        get(target, propKey) {
+            if (propKey in proxyApis) {
+                return proxyApis[propKey];
+            }
+            return target[propKey];
+        }
+    });
+    const tsLs = ts.createLanguageService(proxyHost);
     const program = tsLs.getProgram();
     const typeChecker = program.getTypeChecker();
+    let globalPropNames = [];
+    globalPropNames = getComponentMeta(globalComponentName).props.map(prop => prop.name);
     return {
-        getGlobalPropNames,
         getExportNames,
         getComponentMeta,
+        __internal__: {
+            program,
+            tsLs,
+            typeChecker,
+        },
     };
-    /**
-     * Get helper array to map internal properties added by vue to any components
-     *
-     * @example
-     * ```ts
-     * import { createComponentMetaChecker } from 'vue-component-meta'
-     *
-     * const checker = createComponentMetaChecker('path/to/tsconfig.json')
-     * const meta = checker.getComponentMeta('path/to/component.vue')
-     * const globalPropNames = checker.getGlobalPropNames();
-     * const props = meta.props.filter(prop => !globalPropNames.includes(prop.name))
-     * ```
-     */
-    function getGlobalPropNames() {
-        const meta = getComponentMeta(globalComponentName);
-        return meta.props.map(prop => prop.name);
-    }
     function getMetaFileName(fileName) {
         return (fileName.endsWith('.vue') ? fileName : fileName.substring(0, fileName.lastIndexOf('.'))) + '.meta.ts';
     }
     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) {
@@ -170,20 +104,39 @@ function createComponentMetaChecker(tsconfigPath) {
         };
         function getProps() {
             const $props = symbolProperties.find(prop => prop.escapedName === '$props');
+            const propEventRegex = /^(on[A-Z])/;
             let result = [];
             if ($props) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($props, symbolNode);
-                const properties = type.getApparentProperties();
-                const { resolveSymbolSchema } = createSchemaResolvers(typeChecker, symbolNode);
-                result = properties.map(resolveSymbolSchema);
+                const properties = type.getProperties();
+                result = properties
+                    .map((prop) => {
+                    const { resolveNestedProperties, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions);
+                    return resolveNestedProperties(prop);
+                })
+                    .filter((prop) => !prop.name.match(propEventRegex));
+            }
+            // fill global
+            for (const prop of result) {
+                prop.global = globalPropNames.includes(prop.name);
             }
             // fill defaults
-            if (componentPath.endsWith('.vue') && exportName === 'default') {
-                const defaults = findCmponentDefaultProps(componentPath);
-                for (const propName in defaults) {
-                    const prop = result.find(p => p.name === propName);
-                    if (prop) {
-                        prop.default = defaults[propName];
+            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 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.default;
+                    if (defaultExp.required !== undefined) {
+                        prop.required = defaultExp.required;
+                    }
+                    if (prop.default !== undefined) {
+                        prop.required = false; // props with default are always optional
                     }
                 }
             }
@@ -194,13 +147,10 @@ function createComponentMetaChecker(tsconfigPath) {
             if ($emit) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($emit, symbolNode);
                 const calls = type.getCallSignatures();
-                const { resolveSchema } = createSchemaResolvers(typeChecker, symbolNode);
-                return calls.map(call => ({
-                    name: typeChecker.getTypeOfSymbolAtLocation(call.parameters[0], symbolNode).value,
-                    type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(call.parameters[1], symbolNode)),
-                    signature: typeChecker.signatureToString(call),
-                    schema: typeChecker.getTypeArguments(typeChecker.getTypeOfSymbolAtLocation(call.parameters[1], symbolNode)).map(resolveSchema),
-                }));
+                return calls.map((call) => {
+                    const { resolveEventSignature, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions);
+                    return resolveEventSignature(call);
+                }).filter(event => event.name);
             }
             return [];
         }
@@ -211,11 +161,10 @@ function createComponentMetaChecker(tsconfigPath) {
             if ($slots) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($slots, symbolNode);
                 const properties = type.getProperties();
-                return properties.map(prop => ({
-                    name: prop.getName(),
-                    type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(typeChecker.getTypeOfSymbolAtLocation(prop, symbolNode).getCallSignatures()[0].parameters[0], symbolNode)),
-                    description: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
-                }));
+                return properties.map((prop) => {
+                    const { resolveSlotProperties, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions);
+                    return resolveSlotProperties(prop);
+                });
             }
             return [];
         }
@@ -224,11 +173,10 @@ function createComponentMetaChecker(tsconfigPath) {
             // only exposed props will have a syntheticOrigin
             Boolean(prop.syntheticOrigin));
             if (exposed.length) {
-                return exposed.map(expose => ({
-                    name: expose.getName(),
-                    type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(expose, symbolNode)),
-                    description: ts.displayPartsToString(expose.getDocumentationComment(typeChecker)),
-                }));
+                return exposed.map((prop) => {
+                    const { resolveExposedProperties, } = createSchemaResolvers(typeChecker, symbolNode, checkerOptions);
+                    return resolveExposedProperties(prop);
+                });
             }
             return [];
         }
@@ -263,28 +211,175 @@ function createComponentMetaChecker(tsconfigPath) {
     }
 }
 exports.createComponentMetaChecker = createComponentMetaChecker;
-function findCmponentDefaultProps(componentPath) {
-    const fileText = ts.sys.readFile(componentPath);
-    if (fileText === undefined) {
-        throw new Error(`${componentPath} not found`);
+function createSchemaResolvers(typeChecker, symbolNode, { rawType, schema: options }) {
+    var _a;
+    const enabled = !!options;
+    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') {
+            return true;
+        }
+        if (ignore.length === 0) {
+            return false;
+        }
+        return ignore.includes(type);
     }
-    const vueSourceFile = vue.createSourceFile(componentPath, fileText, {}, {}, ts);
-    const descriptor = vueSourceFile.getDescriptor();
-    const scriptSetupRanges = vueSourceFile.getScriptSetupRanges();
-    const result = {};
-    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);
-        const obj = findObjectLiteralExpression(ast);
-        if (obj) {
-            for (const prop of obj.properties) {
-                if (ts.isPropertyAssignment(prop)) {
-                    const name = prop.name.getText(ast);
-                    const exp = prop.initializer.getText(ast);
-                    result[name] = exp;
+    function setVisited(subtype) {
+        const type = typeChecker.typeToString(subtype);
+        ignore.push(type);
+    }
+    function reducer(acc, cur) {
+        acc[cur.name] = cur;
+        return acc;
+    }
+    function resolveNestedProperties(prop) {
+        var _a, _b, _c;
+        const subtype = typeChecker.getTypeOfSymbolAtLocation(prop, symbolNode);
+        const schema = enabled ? resolveSchema(subtype) : undefined;
+        return {
+            name: prop.getEscapedName().toString(),
+            global: false,
+            description: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
+            tags: prop.getJsDocTags(typeChecker).map(tag => {
+                var _a;
+                return ({
+                    name: tag.name,
+                    text: (_a = tag.text) === null || _a === void 0 ? void 0 : _a.map(part => part.text).join(''),
+                });
+            }),
+            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,
+        };
+    }
+    function resolveSlotProperties(prop) {
+        const subtype = typeChecker.getTypeOfSymbolAtLocation(typeChecker.getTypeOfSymbolAtLocation(prop, symbolNode).getCallSignatures()[0].parameters[0], symbolNode);
+        const schema = enabled ? resolveSchema(subtype) : undefined;
+        return {
+            name: prop.getName(),
+            type: typeChecker.typeToString(subtype),
+            rawType: rawType ? subtype : undefined,
+            description: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
+            schema,
+        };
+    }
+    function resolveExposedProperties(expose) {
+        const subtype = typeChecker.getTypeOfSymbolAtLocation(expose, symbolNode);
+        const schema = enabled ? resolveSchema(subtype) : undefined;
+        return {
+            name: expose.getName(),
+            type: typeChecker.typeToString(subtype),
+            rawType: rawType ? subtype : undefined,
+            description: ts.displayPartsToString(expose.getDocumentationComment(typeChecker)),
+            schema,
+        };
+    }
+    function resolveEventSignature(call) {
+        const subtype = typeChecker.getTypeOfSymbolAtLocation(call.parameters[1], symbolNode);
+        const schema = enabled
+            ? typeChecker.getTypeArguments(subtype).map(resolveSchema)
+            : undefined;
+        return {
+            name: typeChecker.getTypeOfSymbolAtLocation(call.parameters[0], symbolNode).value,
+            type: typeChecker.typeToString(subtype),
+            rawType: rawType ? subtype : undefined,
+            signature: typeChecker.signatureToString(call),
+            schema,
+        };
+    }
+    function resolveCallbackSchema(signature) {
+        const schema = enabled && signature.parameters.length > 0
+            ? typeChecker
+                .getTypeArguments(typeChecker.getTypeOfSymbolAtLocation(signature.parameters[0], symbolNode))
+                .map(resolveSchema)
+            : undefined;
+        return {
+            kind: 'event',
+            type: typeChecker.signatureToString(signature),
+            schema,
+        };
+    }
+    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)
+            };
+        }
+        // @ts-ignore - typescript internal, isArrayLikeType exists
+        else if (typeChecker.isArrayLikeType(subtype)) {
+            schema = {
+                kind: 'array',
+                type,
+                schema: typeChecker.getTypeArguments(subtype).map(resolveSchema)
+            };
+        }
+        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,
+        resolveSchema,
+    };
+}
+function readVueComponentDefaultProps(vueFileText, printer) {
+    let result = {};
+    scriptSetupWorker();
+    scriptWorker();
+    return result;
+    function scriptSetupWorker() {
+        var _a;
+        const vueSourceFile = vue.createSourceFile('/tmp.vue', vueFileText, {}, {}, ts);
+        const descriptor = vueSourceFile.getDescriptor();
+        const scriptSetupRanges = vueSourceFile.getScriptSetupRanges();
+        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);
+            const obj = findObjectLiteralExpression(ast);
+            if (obj) {
+                for (const prop of obj.properties) {
+                    if (ts.isPropertyAssignment(prop)) {
+                        const name = prop.name.getText(ast);
+                        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,
+                        };
+                    }
                 }
             }
         }
+        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;
@@ -298,7 +393,113 @@ function findCmponentDefaultProps(componentPath) {
             return result;
         }
     }
+    function scriptWorker() {
+        const vueSourceFile = vue.createSourceFile('/tmp.vue', vueFileText, {}, {}, ts);
+        const descriptor = vueSourceFile.getDescriptor();
+        if (descriptor.script) {
+            const scriptResult = readTsComponentDefaultProps(descriptor.script.lang, descriptor.script.content, 'default', printer);
+            for (const [key, value] of Object.entries(scriptResult)) {
+                result[key] = value;
+            }
+        }
+    }
+}
+function readTsComponentDefaultProps(lang, tsFileText, exportName, printer) {
+    const ast = ts.createSourceFile('/tmp.' + lang, tsFileText, ts.ScriptTarget.Latest);
+    const props = getPropsNode();
+    if (props) {
+        return resolvePropsOption(ast, props, printer);
+    }
+    return {};
+    function getComponentNode() {
+        let result;
+        if (exportName === 'default') {
+            ast.forEachChild(child => {
+                if (ts.isExportAssignment(child)) {
+                    result = child.expression;
+                }
+            });
+        }
+        else {
+            ast.forEachChild(child => {
+                var _a;
+                if (ts.isVariableStatement(child)
+                    && ((_a = child.modifiers) === null || _a === void 0 ? void 0 : _a.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword))) {
+                    for (const dec of child.declarationList.declarations) {
+                        if (dec.name.getText(ast) === exportName) {
+                            result = dec.initializer;
+                        }
+                    }
+                }
+            });
+        }
+        return result;
+    }
+    function getComponentOptionsNode() {
+        const component = getComponentNode();
+        if (component) {
+            // export default { ... }
+            if (ts.isObjectLiteralExpression(component)) {
+                return component;
+            }
+            // export default defineComponent({ ... })
+            // export default Vue.extend({ ... })
+            else if (ts.isCallExpression(component)) {
+                if (component.arguments.length) {
+                    const arg = component.arguments[0];
+                    if (ts.isObjectLiteralExpression(arg)) {
+                        return arg;
+                    }
+                }
+            }
+        }
+    }
+    function getPropsNode() {
+        const options = getComponentOptionsNode();
+        const props = options === null || options === void 0 ? void 0 : options.properties.find(prop => { var _a; return ((_a = prop.name) === null || _a === void 0 ? void 0 : _a.getText(ast)) === 'props'; });
+        if (props && ts.isPropertyAssignment(props)) {
+            if (ts.isObjectLiteralExpression(props.initializer)) {
+                return props.initializer;
+            }
+        }
+    }
+}
+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;
 }
-exports.findCmponentDefaultProps = findCmponentDefaultProps;
+function resolveDefaultOptionExpression(_default) {
+    if (ts.isArrowFunction(_default)) {
+        if (ts.isBlock(_default.body)) {
+            return _default; // TODO
+        }
+        else if (ts.isParenthesizedExpression(_default.body)) {
+            return _default.body.expression;
+        }
+        else {
+            return _default.body;
+        }
+    }
+    return _default;
+}
 //# sourceMappingURL=index.js.map

package/out/types.d.ts

@@ -0,0 +1,67 @@
+export interface ComponentMeta {
+    props: PropertyMeta[];
+    events: EventMeta[];
+    slots: SlotMeta[];
+    exposed: ExposeMeta[];
+}
+export interface PropertyMeta {
+    name: string;
+    default?: string;
+    description: string;
+    global: boolean;
+    required: boolean;
+    type: string;
+    rawType?: ts.Type;
+    tags: {
+        name: string;
+        text?: string;
+    }[];
+    schema?: PropertyMetaSchema;
+}
+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;
+}
+export interface ExposeMeta {
+    name: string;
+    description: string;
+    type: string;
+    rawType?: ts.Type;
+    schema?: PropertyMetaSchema;
+}
+export declare type PropertyMetaSchema = string | {
+    kind: 'enum';
+    type: string;
+    schema?: PropertyMetaSchema[];
+} | {
+    kind: 'array';
+    type: string;
+    schema?: PropertyMetaSchema[];
+} | {
+    kind: 'event';
+    type: string;
+    schema?: PropertyMetaSchema[];
+} | {
+    kind: 'object';
+    type: string;
+    schema?: Record<string, PropertyMeta>;
+};
+export declare type MetaCheckerSchemaOptions = boolean | {
+    ignore?: string[];
+};
+export interface MetaCheckerOptions {
+    schema?: MetaCheckerSchemaOptions;
+    forceUseTs?: boolean;
+    printer?: import('typescript').PrinterOptions;
+    rawType?: boolean;
+}

package/out/types.js

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

package/package.json

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