vue-component-meta 3.1.8 → 3.2.1

package/index.d.ts

@@ -1,27 +1,21 @@
 import * as ts from 'typescript';
 import type { MetaCheckerOptions } from './lib/types';
 export * from './lib/types';
-export declare function createCheckerByJson(rootPath: string, json: any, checkerOptions?: MetaCheckerOptions): {
+export declare function createCheckerByJson(rootDir: string, json: any, checkerOptions?: MetaCheckerOptions): {
     getExportNames: (componentPath: string) => string[];
-    getComponentMeta: (componentPath: string, exportName?: string) => import("./lib/types").ComponentMeta;
+    getComponentMeta(fileName: string, exportName?: string): import("./lib/types").ComponentMeta;
     updateFile(fileName: string, text: string): void;
     deleteFile(fileName: string): void;
     reload(): void;
     clearCache(): void;
     getProgram(): ts.Program | undefined;
-    __internal__: {
-        tsLs: ts.LanguageService;
-    };
 };
 export declare function createChecker(tsconfig: string, checkerOptions?: MetaCheckerOptions): {
     getExportNames: (componentPath: string) => string[];
-    getComponentMeta: (componentPath: string, exportName?: string) => import("./lib/types").ComponentMeta;
+    getComponentMeta(fileName: string, exportName?: string): import("./lib/types").ComponentMeta;
     updateFile(fileName: string, text: string): void;
     deleteFile(fileName: string): void;
     reload(): void;
     clearCache(): void;
     getProgram(): ts.Program | undefined;
-    __internal__: {
-        tsLs: ts.LanguageService;
-    };
 };

package/index.js

@@ -10,19 +10,63 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCheckerByJson = createCheckerByJson;
 exports.createChecker = createChecker;
-const ts = require("typescript");
-const base_1 = require("./lib/base");
+const core = __importStar(require("@vue/language-core"));
+const path_browserify_1 = require("path-browserify");
+const ts = __importStar(require("typescript"));
+const checker_1 = require("./lib/checker");
 __exportStar(require("./lib/types"), exports);
-function createCheckerByJson(rootPath, json, checkerOptions = {}) {
-    return (0, base_1.createCheckerByJsonConfigBase)(ts, rootPath, json, checkerOptions);
+function createCheckerByJson(rootDir, json, checkerOptions = {}) {
+    rootDir = rootDir.replace(/\\/g, '/');
+    return (0, checker_1.createCheckerBase)(ts, () => {
+        const commandLine = core.createParsedCommandLineByJson(ts, ts.sys, rootDir, json);
+        const { fileNames } = ts.parseJsonConfigFileContent(json, ts.sys, rootDir, {}, undefined, undefined, core.getAllExtensions(commandLine.vueOptions)
+            .map(extension => ({
+            extension: extension.slice(1),
+            isMixedContent: true,
+            scriptKind: ts.ScriptKind.Deferred,
+        })));
+        return [commandLine, fileNames];
+    }, checkerOptions, rootDir);
 }
 function createChecker(tsconfig, checkerOptions = {}) {
-    return (0, base_1.createCheckerBase)(ts, tsconfig, checkerOptions);
+    tsconfig = tsconfig.replace(/\\/g, '/');
+    return (0, checker_1.createCheckerBase)(ts, () => {
+        const commandLine = core.createParsedCommandLine(ts, ts.sys, tsconfig);
+        const { fileNames } = ts.parseJsonSourceFileConfigFileContent(ts.readJsonConfigFile(tsconfig, ts.sys.readFile), ts.sys, path_browserify_1.posix.dirname(tsconfig), {}, tsconfig, undefined, core.getAllExtensions(commandLine.vueOptions)
+            .map(extension => ({
+            extension: extension.slice(1),
+            isMixedContent: true,
+            scriptKind: ts.ScriptKind.Deferred,
+        })));
+        return [commandLine, fileNames];
+    }, checkerOptions, path_browserify_1.posix.dirname(tsconfig));
 }
 //# sourceMappingURL=index.js.map

package/lib/checker.d.ts

@@ -0,0 +1,16 @@
+import * as core from '@vue/language-core';
+import type * as ts from 'typescript';
+import type { MetaCheckerOptions } from './types';
+export declare function createCheckerBase(ts: typeof import('typescript'), getConfigAndFiles: () => [
+    commandLine: core.ParsedCommandLine,
+    fileNames: string[]
+], checkerOptions: MetaCheckerOptions, rootPath: string): {
+    getExportNames: (componentPath: string) => string[];
+    getComponentMeta(fileName: string, exportName?: string): import("./types").ComponentMeta;
+    updateFile(fileName: string, text: string): void;
+    deleteFile(fileName: string): void;
+    reload(): void;
+    clearCache(): void;
+    getProgram(): ts.Program | undefined;
+};
+export declare function getExport(ts: typeof import('typescript'), program: ts.Program, sourceFile: ts.SourceFile, exportName: string): ts.Expression | undefined;

package/lib/checker.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCheckerBase = createCheckerBase;
+exports.getExport = getExport;
+const typescript_1 = require("@volar/typescript");
+const core = __importStar(require("@vue/language-core"));
+const componentMeta_1 = require("./componentMeta");
+function createCheckerBase(ts, getConfigAndFiles, checkerOptions, rootPath) {
+    let [{ vueOptions, options, projectReferences }, fileNames] = getConfigAndFiles();
+    /**
+     * Used to lookup if a file is referenced.
+     */
+    let fileNamesSet = new Set(fileNames.map(path => path.replace(/\\/g, '/')));
+    let projectVersion = 0;
+    const projectHost = {
+        getCurrentDirectory: () => rootPath,
+        getProjectVersion: () => projectVersion.toString(),
+        getCompilationSettings: () => options,
+        getScriptFileNames: () => [...fileNamesSet],
+        getProjectReferences: () => projectReferences,
+    };
+    const scriptSnapshots = new Map();
+    const vueLanguagePlugin = core.createVueLanguagePlugin(ts, projectHost.getCompilationSettings(), vueOptions, id => id);
+    const language = core.createLanguage([
+        vueLanguagePlugin,
+        {
+            getLanguageId(fileName) {
+                return (0, typescript_1.resolveFileLanguageId)(fileName);
+            },
+        },
+    ], new core.FileMap(ts.sys.useCaseSensitiveFileNames), fileName => {
+        let snapshot = scriptSnapshots.get(fileName);
+        if (!scriptSnapshots.has(fileName)) {
+            const fileText = ts.sys.readFile(fileName);
+            if (fileText !== undefined) {
+                scriptSnapshots.set(fileName, ts.ScriptSnapshot.fromString(fileText));
+            }
+            else {
+                scriptSnapshots.set(fileName, undefined);
+            }
+        }
+        snapshot = scriptSnapshots.get(fileName);
+        if (snapshot) {
+            language.scripts.set(fileName, snapshot);
+        }
+        else {
+            language.scripts.delete(fileName);
+        }
+    });
+    const { languageServiceHost } = (0, typescript_1.createLanguageServiceHost)(ts, ts.sys, language, s => s, projectHost);
+    const tsLs = ts.createLanguageService(languageServiceHost);
+    const printer = ts.createPrinter(checkerOptions.printer);
+    const getScriptKind = languageServiceHost.getScriptKind?.bind(languageServiceHost);
+    if (checkerOptions.forceUseTs ?? true) {
+        languageServiceHost.getScriptKind = fileName => {
+            const scriptKind = getScriptKind(fileName);
+            if (vueOptions.extensions.some(ext => fileName.endsWith(ext))) {
+                if (scriptKind === ts.ScriptKind.JS) {
+                    return ts.ScriptKind.TS;
+                }
+                if (scriptKind === ts.ScriptKind.JSX) {
+                    return ts.ScriptKind.TSX;
+                }
+            }
+            return scriptKind;
+        };
+    }
+    return {
+        getExportNames,
+        getComponentMeta(fileName, exportName = 'default') {
+            fileName = fileName.replace(/\\/g, '/');
+            const [program, sourceFile] = getProgramAndFile(fileName);
+            const componentNode = getExport(ts, program, sourceFile, exportName);
+            if (!componentNode) {
+                throw new Error(`Export '${exportName}' not found in '${sourceFile.fileName}'.`);
+            }
+            const checker = program.getTypeChecker();
+            const componentType = checker.getTypeAtLocation(componentNode);
+            return (0, componentMeta_1.getComponentMeta)(ts, checker, printer, language, componentNode, componentType, checkerOptions.schema ?? false, {
+                noDeclarations: checkerOptions.noDeclarations ?? true,
+                rawType: checkerOptions.rawType ?? false,
+            });
+        },
+        updateFile(fileName, text) {
+            fileName = fileName.replace(/\\/g, '/');
+            scriptSnapshots.set(fileName, ts.ScriptSnapshot.fromString(text));
+            // Ensure the file is referenced
+            fileNamesSet.add(fileName);
+            projectVersion++;
+        },
+        deleteFile(fileName) {
+            fileName = fileName.replace(/\\/g, '/');
+            fileNamesSet.delete(fileName);
+            projectVersion++;
+        },
+        reload() {
+            [{ vueOptions, options, projectReferences }, fileNames] = getConfigAndFiles();
+            fileNamesSet = new Set(fileNames.map(path => path.replace(/\\/g, '/')));
+            this.clearCache();
+        },
+        clearCache() {
+            scriptSnapshots.clear();
+            projectVersion++;
+        },
+        getProgram() {
+            return tsLs.getProgram();
+        },
+    };
+    function getProgramAndFile(componentPath) {
+        let program = tsLs.getProgram();
+        let sourceFile = program.getSourceFile(componentPath);
+        if (!sourceFile) {
+            fileNamesSet.add(componentPath);
+            projectVersion++;
+            program = tsLs.getProgram();
+            sourceFile = program.getSourceFile(componentPath);
+        }
+        return [program, sourceFile];
+    }
+    function getExportNames(componentPath) {
+        const [program, sourceFile] = getProgramAndFile(componentPath);
+        return getExports(program, sourceFile).map(e => e.getName());
+    }
+}
+function getExport(ts, program, sourceFile, exportName) {
+    const exports = getExports(program, sourceFile);
+    const symbol = exports.find(e => e.getName() === exportName);
+    if (symbol?.valueDeclaration) {
+        const decl = symbol.valueDeclaration;
+        if (ts.isExportAssignment(decl)) {
+            return decl.expression;
+        }
+        if (ts.isVariableDeclaration(decl)) {
+            return decl.initializer;
+        }
+    }
+}
+function getExports(program, sourceFile) {
+    const typeChecker = program.getTypeChecker();
+    const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+    return moduleSymbol ? typeChecker.getExportsOfModule(moduleSymbol) : [];
+}
+//# sourceMappingURL=checker.js.map

package/lib/componentMeta.d.ts

@@ -0,0 +1,7 @@
+import * as core from '@vue/language-core';
+import type * as ts from 'typescript';
+import type { ComponentMeta, MetaCheckerSchemaOptions } from './types';
+export declare function getComponentMeta(ts: typeof import('typescript'), typeChecker: ts.TypeChecker, printer: ts.Printer, language: core.Language<string>, componentNode: ts.Node, componentType: ts.Type, options: MetaCheckerSchemaOptions, deprecatedOptions?: {
+    noDeclarations: boolean;
+    rawType: boolean;
+}): ComponentMeta;

package/lib/componentMeta.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentMeta = getComponentMeta;
+const core = __importStar(require("@vue/language-core"));
+const helpers_1 = require("./helpers");
+const schemaResolvers_1 = require("./schemaResolvers");
+const scriptSetup_1 = require("./scriptSetup");
+function getComponentMeta(ts, typeChecker, printer, language, componentNode, componentType, options, deprecatedOptions = { noDeclarations: true, rawType: false }) {
+    const componentSymbol = typeChecker.getSymbolAtLocation(componentNode);
+    let componentFile = componentNode.getSourceFile();
+    if (componentSymbol) {
+        const symbol = componentSymbol.flags & ts.SymbolFlags.Alias
+            ? typeChecker.getAliasedSymbol(componentSymbol)
+            : componentType.symbol;
+        const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+        if (declaration) {
+            componentFile = declaration.getSourceFile();
+            componentNode = declaration;
+        }
+    }
+    let name;
+    let description;
+    let type;
+    let props;
+    let events;
+    let slots;
+    let exposed;
+    const meta = {
+        get name() {
+            return name ?? (name = getName());
+        },
+        get description() {
+            return description ?? (description = getDescription());
+        },
+        get type() {
+            return type ?? (type = getType());
+        },
+        get props() {
+            return props ?? (props = getProps());
+        },
+        get events() {
+            return events ?? (events = getEvents());
+        },
+        get slots() {
+            return slots ?? (slots = getSlots());
+        },
+        get exposed() {
+            return exposed ?? (exposed = getExposed());
+        },
+    };
+    return meta;
+    function getType() {
+        return (0, helpers_1.inferComponentType)(componentType) ?? 0;
+    }
+    function getProps() {
+        const propsType = (0, helpers_1.inferComponentProps)(typeChecker, componentType);
+        if (!propsType) {
+            return [];
+        }
+        let result = [];
+        const properties = propsType.getProperties();
+        const eventProps = new Set(meta.events.map(event => `on${event.name.charAt(0).toUpperCase()}${event.name.slice(1)}`));
+        result = properties
+            .map(prop => {
+            const { resolveNestedProperties, } = (0, schemaResolvers_1.createSchemaResolvers)(ts, typeChecker, printer, language, options, deprecatedOptions);
+            return resolveNestedProperties(prop);
+        })
+            .filter((prop) => !!prop && !eventProps.has(prop.name));
+        const defaults = (0, scriptSetup_1.getDefaultsFromScriptSetup)(ts, printer, language, componentFile.fileName);
+        for (const prop of result) {
+            if (prop.name.match(/^onVnode[A-Z]/)) {
+                prop.name = 'onVue:' + prop.name['onVnode'.length]?.toLowerCase() + prop.name.slice('onVnode'.length + 1);
+            }
+            prop.default ??= defaults?.get(prop.name);
+        }
+        return result;
+    }
+    function getEvents() {
+        const emitType = (0, helpers_1.inferComponentEmit)(typeChecker, componentType);
+        if (emitType) {
+            const calls = emitType.getCallSignatures();
+            return calls.map(call => {
+                const { resolveEventSignature, } = (0, schemaResolvers_1.createSchemaResolvers)(ts, typeChecker, printer, language, options, deprecatedOptions);
+                return resolveEventSignature(call);
+            }).filter(event => event.name);
+        }
+        return [];
+    }
+    function getSlots() {
+        const slotsType = (0, helpers_1.inferComponentSlots)(typeChecker, componentType);
+        if (slotsType) {
+            const properties = slotsType.getProperties();
+            return properties.map(prop => {
+                const { resolveSlotProperties, } = (0, schemaResolvers_1.createSchemaResolvers)(ts, typeChecker, printer, language, options, deprecatedOptions);
+                return resolveSlotProperties(prop);
+            });
+        }
+        return [];
+    }
+    function getExposed() {
+        const exposedType = (0, helpers_1.inferComponentExposed)(typeChecker, componentType);
+        if (exposedType) {
+            const propsType = (0, helpers_1.inferComponentProps)(typeChecker, componentType);
+            const propsProperties = propsType?.getProperties() ?? [];
+            const properties = exposedType.getProperties().filter(prop => 
+            // only exposed props will have at least one declaration and no valueDeclaration
+            prop.declarations?.length
+                && !prop.valueDeclaration
+                // Cross-check with props to avoid including props here
+                && (!propsProperties.length || !propsProperties.some(({ name }) => name === prop.name))
+                // Exclude $slots
+                && prop.name !== '$slots');
+            return properties.map(prop => {
+                const { resolveExposedProperties, } = (0, schemaResolvers_1.createSchemaResolvers)(ts, typeChecker, printer, language, options, deprecatedOptions);
+                return resolveExposedProperties(prop);
+            });
+        }
+        return [];
+    }
+    function getName() {
+        let decl = componentNode;
+        // const __VLS_export = ...
+        const text = componentFile.text.slice(decl.pos, decl.end);
+        if (text.includes(core.names._export)) {
+            ts.forEachChild(componentFile, child2 => {
+                if (ts.isVariableStatement(child2)) {
+                    for (const { name, initializer } of child2.declarationList.declarations) {
+                        if (name.getText() === core.names._export && initializer) {
+                            decl = initializer;
+                        }
+                    }
+                }
+            });
+        }
+        return core.parseOptionsFromExtression(ts, decl, componentFile)?.name?.node.text;
+    }
+    function getDescription() {
+        // Try to get JSDoc comments from the node using TypeScript API
+        const jsDocComments = ts.getJSDocCommentsAndTags(componentNode);
+        for (const jsDoc of jsDocComments) {
+            if (ts.isJSDoc(jsDoc) && jsDoc.comment) {
+                // Handle both string and array of comment parts
+                if (typeof jsDoc.comment === 'string') {
+                    return jsDoc.comment;
+                }
+                else if (Array.isArray(jsDoc.comment)) {
+                    return jsDoc.comment.map(part => part.text || '').join('');
+                }
+            }
+        }
+        // Fallback to symbol documentation
+        const symbol = typeChecker.getSymbolAtLocation(componentNode);
+        if (symbol) {
+            const description = ts.displayPartsToString(symbol.getDocumentationComment(typeChecker));
+            return description || undefined;
+        }
+    }
+}
+//# sourceMappingURL=componentMeta.js.map

package/lib/helpers.d.ts

@@ -0,0 +1,6 @@
+import type * as ts from 'typescript';
+export declare function inferComponentType(componentType: ts.Type): 1 | 2 | undefined;
+export declare function inferComponentProps(typeChecker: ts.TypeChecker, componentType: ts.Type): ts.Type | undefined;
+export declare function inferComponentSlots(typeChecker: ts.TypeChecker, componentType: ts.Type): ts.Type | undefined;
+export declare function inferComponentEmit(typeChecker: ts.TypeChecker, componentType: ts.Type): ts.Type | undefined;
+export declare function inferComponentExposed(typeChecker: ts.TypeChecker, componentType: ts.Type): ts.Type | undefined;

package/lib/helpers.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferComponentType = inferComponentType;
+exports.inferComponentProps = inferComponentProps;
+exports.inferComponentSlots = inferComponentSlots;
+exports.inferComponentEmit = inferComponentEmit;
+exports.inferComponentExposed = inferComponentExposed;
+function inferComponentType(componentType) {
+    const constructSignatures = componentType.getConstructSignatures();
+    const callSignatures = componentType.getCallSignatures();
+    for (const _sig of constructSignatures) {
+        return 1;
+    }
+    for (const _sig of callSignatures) {
+        return 2;
+    }
+}
+function inferComponentProps(typeChecker, componentType) {
+    const constructSignatures = componentType.getConstructSignatures();
+    const callSignatures = componentType.getCallSignatures();
+    for (const sig of constructSignatures) {
+        const retType = sig.getReturnType();
+        const props = findProperty(typeChecker, retType, '$props');
+        if (props) {
+            return props;
+        }
+    }
+    for (const sig of callSignatures) {
+        if (sig.parameters.length > 0) {
+            const props = sig.parameters[0];
+            if (props) {
+                return typeChecker.getTypeOfSymbol(props);
+            }
+        }
+    }
+}
+function inferComponentSlots(typeChecker, componentType) {
+    const constructSignatures = componentType.getConstructSignatures();
+    const callSignatures = componentType.getCallSignatures();
+    for (const sig of constructSignatures) {
+        const retType = sig.getReturnType();
+        const slots = findProperty(typeChecker, retType, '$slots');
+        if (slots) {
+            return slots;
+        }
+    }
+    for (const sig of callSignatures) {
+        if (sig.parameters.length > 1) {
+            const ctxParam = sig.parameters[1];
+            if (ctxParam) {
+                const ctxType = typeChecker.getTypeOfSymbol(ctxParam);
+                const slots = findProperty(typeChecker, ctxType, 'slots');
+                if (slots) {
+                    return slots;
+                }
+            }
+        }
+    }
+}
+function inferComponentEmit(typeChecker, componentType) {
+    const constructSignatures = componentType.getConstructSignatures();
+    const callSignatures = componentType.getCallSignatures();
+    for (const sig of constructSignatures) {
+        const retType = sig.getReturnType();
+        const emit = findProperty(typeChecker, retType, '$emit');
+        if (emit) {
+            return emit;
+        }
+    }
+    for (const sig of callSignatures) {
+        if (sig.parameters.length > 1) {
+            const ctxParam = sig.parameters[1];
+            if (ctxParam) {
+                const ctxType = typeChecker.getTypeOfSymbol(ctxParam);
+                const emitType = findProperty(typeChecker, ctxType, 'emit');
+                if (emitType) {
+                    return emitType;
+                }
+            }
+        }
+    }
+}
+function inferComponentExposed(typeChecker, componentType) {
+    const constructSignatures = componentType.getConstructSignatures();
+    const callSignatures = componentType.getCallSignatures();
+    for (const sig of constructSignatures) {
+        return sig.getReturnType();
+    }
+    for (const sig of callSignatures) {
+        if (sig.parameters.length > 2) {
+            const exposeParam = sig.parameters[2];
+            if (exposeParam) {
+                const exposeType = typeChecker.getTypeOfSymbol(exposeParam);
+                const callSignatures = exposeType.getCallSignatures();
+                for (const callSig of callSignatures) {
+                    const params = callSig.getParameters();
+                    if (params.length > 0) {
+                        return typeChecker.getTypeOfSymbol(params[0]);
+                    }
+                }
+            }
+        }
+    }
+}
+function findProperty(typeChecker, type, property) {
+    const symbol = type.getProperty(property);
+    if (symbol) {
+        return typeChecker.getTypeOfSymbol(symbol);
+    }
+    if (type.isUnionOrIntersection()) {
+        for (const sub of type.types) {
+            const found = findProperty(typeChecker, sub, property);
+            if (found) {
+                return found;
+            }
+        }
+    }
+}
+//# sourceMappingURL=helpers.js.map

package/lib/schemaResolvers.d.ts

@@ -0,0 +1,13 @@
+import type * as core from '@vue/language-core';
+import type * as ts from 'typescript';
+import type { EventMeta, ExposeMeta, PropertyMeta, PropertyMetaSchema, SlotMeta } from './types';
+export declare function createSchemaResolvers(ts: typeof import('typescript'), typeChecker: ts.TypeChecker, printer: ts.Printer, language: core.Language<string>, options: import('./types').MetaCheckerSchemaOptions, deprecatedOptions: {
+    noDeclarations: boolean;
+    rawType: boolean;
+}): {
+    resolveNestedProperties: (propSymbol: ts.Symbol) => PropertyMeta;
+    resolveSlotProperties: (prop: ts.Symbol) => SlotMeta;
+    resolveEventSignature: (call: ts.Signature) => EventMeta;
+    resolveExposedProperties: (expose: ts.Symbol) => ExposeMeta;
+    resolveSchema: (subtype: ts.Type) => PropertyMetaSchema;
+};