vue-component-meta 0.39.2 → 0.39.3

package/out/index.d.ts

@@ -1,53 +1,6 @@
-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 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;
 };
-export declare function findCmponentDefaultProps(componentPath: string): Record<string, string>;

package/out/index.js

@@ -1,83 +1,9 @@
 "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 +14,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,32 +41,36 @@ 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,
     };
-    /**
-     * 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';
     }
@@ -162,6 +92,7 @@ function createComponentMetaChecker(tsconfigPath) {
         }
         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(),
@@ -170,21 +101,29 @@ 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);
+                result = properties
+                    .map(resolveNestedProperties)
+                    .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 = ts.createPrinter(checkerOptions.printer);
+            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;
                 }
             }
             return result;
@@ -194,13 +133,7 @@ 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(resolveEventSignature).filter(event => event.name);
             }
             return [];
         }
@@ -211,11 +144,7 @@ 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(resolveSlotProperties);
             }
             return [];
         }
@@ -224,11 +153,7 @@ 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(resolveExposedProperties);
             }
             return [];
         }
@@ -263,42 +188,278 @@ 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, options = false) {
+    var _a;
+    const enabled = !!options;
+    const ignore = typeof options === 'object' ? (_a = 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);
+    }
+    function reducer(acc, cur) {
+        acc[cur.name] = cur;
+        return acc;
     }
-    const vueSourceFile = vue.createSourceFile(componentPath, fileText, {}, {}, ts);
-    const descriptor = vueSourceFile.getDescriptor();
-    const scriptSetupRanges = vueSourceFile.getScriptSetupRanges();
+    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),
+            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),
+            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),
+            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),
+            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 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, {})
+            };
+        }
+        return resolveEventSchema(subtype);
+    }
+    function resolveArraySchema(subtype) {
+        // @ts-ignore - typescript internal, isArrayLikeType exists
+        if (typeChecker.isArrayLikeType(subtype)) {
+            if (shouldIgnore(subtype)) {
+                return typeChecker.typeToString(subtype);
+            }
+            return {
+                kind: 'array',
+                type: typeChecker.typeToString(subtype),
+                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);
+    }
+    return {
+        resolveNestedProperties,
+        resolveSlotProperties,
+        resolveEventSignature,
+        resolveExposedProperties,
+        resolveCallbackSchema,
+        resolveEventSchema,
+        resolveNestedSchema,
+        resolveArraySchema,
+        resolveSchema,
+    };
+}
+function readVueComponentDefaultProps(vueFileText, printer) {
     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;
+    scriptSetupWorker();
+    sciptWorker();
+    return result;
+    function scriptSetupWorker() {
+        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 exp = printer.printNode(ts.EmitHint.Expression, resolveDefaultOptionExpression(prop.initializer), ast);
+                        ;
+                        result[name] = exp;
+                    }
                 }
             }
+            function findObjectLiteralExpression(node) {
+                if (ts.isObjectLiteralExpression(node)) {
+                    return node;
+                }
+                let result;
+                node.forEachChild(child => {
+                    if (!result) {
+                        result = findObjectLiteralExpression(child);
+                    }
+                });
+                return result;
+            }
         }
-        function findObjectLiteralExpression(node) {
-            if (ts.isObjectLiteralExpression(node)) {
-                return node;
+    }
+    function sciptWorker() {
+        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;
             }
-            let result;
-            node.forEachChild(child => {
-                if (!result) {
-                    result = findObjectLiteralExpression(child);
+        }
+    }
+}
+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 result;
+            }
         }
     }
     return result;
+    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 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;
 }
-exports.findCmponentDefaultProps = findCmponentDefaultProps;
 //# sourceMappingURL=index.js.map

package/out/types.d.ts

@@ -0,0 +1,62 @@
+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;
+    tags: {
+        name: string;
+        text?: string;
+    }[];
+    schema?: PropertyMetaSchema;
+}
+export interface EventMeta {
+    name: string;
+    type: string;
+    signature: string;
+    schema?: PropertyMetaSchema[];
+}
+export interface SlotMeta {
+    name: string;
+    type: string;
+    description: string;
+    schema?: PropertyMetaSchema;
+}
+export interface ExposeMeta {
+    name: string;
+    description: string;
+    type: 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 type MetaCheckerSchemaOptions = boolean | {
+    ignore?: string[];
+};
+export interface MetaCheckerOptions {
+    schema?: MetaCheckerSchemaOptions;
+    forceUseTs?: boolean;
+    printer?: import('typescript').PrinterOptions;
+}

package/out/types.js

@@ -0,0 +1,4 @@
+"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.2",
+	"version": "0.39.3",
 	"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.3"
 	},
 	"peerDependencies": {
 		"typescript": "*"
 	},
-	"gitHead": "eac2dca4206dfa3f92ad50dd53650f924a9e6f94"
+	"gitHead": "57a7b0f627e58277ec34241ccbe4bf5253f7daf8"
 }