vue-component-meta 0.39.0 → 0.39.4

package/out/index.d.ts

@@ -1,25 +1,6 @@
-export declare function createComponentMetaChecker(tsconfigPath: string): {
-    getComponentMeta: (componentPath: string) => {
-        props: {
-            name: string;
-            isOptional: boolean;
-            type: string;
-            documentationComment: string;
-        }[];
-        events: {
-            name: any;
-            parametersType: string;
-            parameters: {
-                name: string;
-                type: string;
-                isOptional: string;
-            }[];
-            documentationComment: string;
-        }[];
-        slots: {
-            name: string;
-            propsType: string;
-            documentationComment: 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) => ComponentMeta;
 };

package/out/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createComponentMetaChecker = void 0;
 const vue = require("@volar/vue-language-core");
 const ts = require("typescript/lib/tsserverlibrary");
-function createComponentMetaChecker(tsconfigPath) {
+function createComponentMetaChecker(tsconfigPath, checkerOptions = {}) {
     const parsedCommandLine = vue.tsShared.createParsedCommandLine(ts, {
         useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
         readDirectory: (path, extensions, exclude, include, depth) => {
@@ -13,98 +13,127 @@ function createComponentMetaChecker(tsconfigPath) {
         readFile: ts.sys.readFile,
     }, tsconfigPath);
     const scriptSnapshot = {};
-    const core = vue.createLanguageContext(Object.assign(Object.assign({}, ts.sys), { getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options), useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames, getCompilationSettings: () => parsedCommandLine.options, getScriptFileNames: () => {
-            const result = [...parsedCommandLine.fileNames];
-            for (const fileName of parsedCommandLine.fileNames) {
-                if (fileName.endsWith('.vue')) {
-                    result.push(fileName + '.meta.ts');
-                }
-            }
-            return result;
+    const globalComponentName = tsconfigPath.replace(/\\/g, '/') + '.global.ts';
+    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),
+                globalComponentName,
+                getMetaFileName(globalComponentName),
+            ];
         }, getProjectReferences: () => parsedCommandLine.projectReferences, getScriptVersion: (fileName) => '0', getScriptSnapshot: (fileName) => {
             if (!scriptSnapshot[fileName]) {
-                const fileText = fileName.endsWith('.meta.ts') ? getMetaScriptContent(fileName) : ts.sys.readFile(fileName);
+                let fileText;
+                if (fileName.endsWith('.meta.ts')) {
+                    fileText = getMetaScriptContent(fileName);
+                }
+                else if (fileName === globalComponentName) {
+                    fileText = `
+						import { defineComponent } from 'vue';
+						export default defineComponent({});
+					`;
+                }
+                else {
+                    fileText = ts.sys.readFile(fileName);
+                }
                 if (fileText !== undefined) {
                     scriptSnapshot[fileName] = ts.ScriptSnapshot.fromString(fileText);
                 }
             }
             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 {
+        getExportNames,
         getComponentMeta,
     };
+    function getMetaFileName(fileName) {
+        return (fileName.endsWith('.vue') ? fileName : fileName.substring(0, fileName.lastIndexOf('.'))) + '.meta.ts';
+    }
     function getMetaScriptContent(fileName) {
         return `
-			import Component from '${fileName.substring(0, fileName.length - '.meta.ts'.length)}';
-			export default new Component();
+			import * as Components from '${fileName.substring(0, fileName.length - '.meta.ts'.length)}';
+			export default {} as { [K in keyof typeof Components]: InstanceType<typeof Components[K]>; };;
 		`;
     }
-    function getComponentMeta(componentPath) {
+    function getExportNames(componentPath) {
+        return _getExports(componentPath).exports.map(e => e.getName());
+    }
+    function getComponentMeta(componentPath, exportName = 'default') {
         var _a;
-        const sourceFile = program === null || program === void 0 ? void 0 : program.getSourceFile(componentPath + '.meta.ts');
-        if (!sourceFile) {
-            throw 'Could not find main source file';
-        }
-        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
-        if (!moduleSymbol) {
-            throw 'Could not find module symbol';
-        }
-        const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
-        let symbolNode;
-        for (const symbol of exportedSymbols) {
-            const [declaration] = (_a = symbol.getDeclarations()) !== null && _a !== void 0 ? _a : [];
-            if (ts.isExportAssignment(declaration)) {
-                symbolNode = declaration.expression;
-            }
-        }
-        if (!symbolNode) {
-            throw 'Could not find symbol node';
+        const { symbolNode, exports } = _getExports(componentPath);
+        const _export = exports.find((property) => property.getName() === exportName);
+        if (!_export) {
+            throw `Could not find export ${exportName}`;
         }
-        const symbolType = typeChecker.getTypeAtLocation(symbolNode);
-        const symbolProperties = symbolType.getProperties();
+        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(),
             slots: getSlots(),
+            exposed: getExposed(),
         };
         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.getProperties();
-                return properties.map(prop => {
-                    var _a, _b;
-                    return ({
-                        name: prop.escapedName,
-                        // @ts-ignore
-                        isOptional: !!((_b = (_a = prop.declarations) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.questionToken),
-                        type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(prop, symbolNode)),
-                        documentationComment: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
-                    });
-                });
+                const properties = type.getApparentProperties();
+                result = properties
+                    .map(resolveNestedProperties)
+                    .filter((prop) => !prop.name.match(propEventRegex));
             }
-            return [];
+            // fill global
+            for (const prop of result) {
+                prop.global = globalPropNames.includes(prop.name);
+            }
+            // fill defaults
+            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;
         }
         function getEvents() {
             const $emit = symbolProperties.find(prop => prop.escapedName === '$emit');
             if ($emit) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($emit, symbolNode);
                 const calls = type.getCallSignatures();
-                return calls.map(call => ({
-                    // @ts-ignore
-                    name: typeChecker.getTypeOfSymbolAtLocation(call.parameters[0], symbolNode).value,
-                    parametersType: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(call.parameters[1], symbolNode)),
-                    // @ts-ignore
-                    parameters: typeChecker.getTypeArguments(typeChecker.getTypeOfSymbolAtLocation(call.parameters[1], symbolNode)).map(arg => ({
-                        name: 'TODO',
-                        type: typeChecker.typeToString(arg),
-                        isOptional: 'TODO',
-                    })),
-                    documentationComment: ts.displayPartsToString(call.getDocumentationComment(typeChecker)),
-                }));
+                return calls.map(resolveEventSignature).filter(event => event.name);
             }
             return [];
         }
@@ -115,16 +144,322 @@ function createComponentMetaChecker(tsconfigPath) {
             if ($slots) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($slots, symbolNode);
                 const properties = type.getProperties();
-                return properties.map(prop => ({
-                    name: prop.escapedName,
-                    propsType: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(typeChecker.getTypeOfSymbolAtLocation(prop, symbolNode).getCallSignatures()[0].parameters[0], symbolNode)),
-                    // props: {}, // TODO
-                    documentationComment: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
-                }));
+                return properties.map(resolveSlotProperties);
+            }
+            return [];
+        }
+        function getExposed() {
+            const exposed = symbolProperties.filter(prop => 
+            // only exposed props will have a syntheticOrigin
+            Boolean(prop.syntheticOrigin));
+            if (exposed.length) {
+                return exposed.map(resolveExposedProperties);
             }
             return [];
         }
     }
+    function _getExports(componentPath) {
+        var _a;
+        const sourceFile = program === null || program === void 0 ? void 0 : program.getSourceFile(getMetaFileName(componentPath));
+        if (!sourceFile) {
+            throw 'Could not find main source file';
+        }
+        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol) {
+            throw 'Could not find module symbol';
+        }
+        const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
+        let symbolNode;
+        for (const symbol of exportedSymbols) {
+            const [declaration] = (_a = symbol.getDeclarations()) !== null && _a !== void 0 ? _a : [];
+            if (ts.isExportAssignment(declaration)) {
+                symbolNode = declaration.expression;
+            }
+        }
+        if (!symbolNode) {
+            throw 'Could not find symbol node';
+        }
+        const exportDefaultType = typeChecker.getTypeAtLocation(symbolNode);
+        const exports = exportDefaultType.getProperties();
+        return {
+            symbolNode,
+            exports,
+        };
+    }
 }
 exports.createComponentMetaChecker = createComponentMetaChecker;
+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;
+    }
+    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 = {};
+    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 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;
+            }
+        }
+    }
+}
+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;
+    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;
+}
 //# 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.0",
+	"version": "0.39.4",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -13,9 +13,10 @@
 		"directory": "packages/vue-component-meta"
 	},
 	"dependencies": {
-		"@volar/vue-language-core": "0.39.0"
+		"@volar/vue-language-core": "0.39.4"
 	},
 	"peerDependencies": {
 		"typescript": "*"
-	}
+	},
+	"gitHead": "e3f6327b11a0a41c1b448c2ecc25ba85b9986dee"
 }