vue-component-meta 0.39.0 → 0.39.2

package/out/index.d.ts

@@ -1,25 +1,53 @@
+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): {
-    getComponentMeta: (componentPath: string) => {
-        props: {
+    getGlobalPropNames: () => string[];
+    getExportNames: (componentPath: string) => string[];
+    getComponentMeta: (componentPath: string, exportName?: string) => {
+        props: PropertyMeta[];
+        events: {
             name: string;
-            isOptional: boolean;
             type: string;
-            documentationComment: string;
-        }[];
-        events: {
-            name: any;
-            parametersType: string;
-            parameters: {
-                name: string;
-                type: string;
-                isOptional: string;
-            }[];
-            documentationComment: string;
+            signature: string;
+            schema: PropertyMetaSchema[];
         }[];
         slots: {
             name: string;
-            propsType: string;
-            documentationComment: string;
+            type: string;
+            description: string;
+        }[];
+        exposed: {
+            name: string;
+            type: string;
+            description: string;
         }[];
     };
 };
+export declare function findCmponentDefaultProps(componentPath: string): Record<string, string>;

package/out/index.js

@@ -1,8 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createComponentMetaChecker = void 0;
+exports.findCmponentDefaultProps = 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) {
     const parsedCommandLine = vue.tsShared.createParsedCommandLine(ts, {
         useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
@@ -13,17 +87,29 @@ function createComponentMetaChecker(tsconfigPath) {
         readFile: ts.sys.readFile,
     }, 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 result = [...parsedCommandLine.fileNames];
-            for (const fileName of parsedCommandLine.fileNames) {
-                if (fileName.endsWith('.vue')) {
-                    result.push(fileName + '.meta.ts');
-                }
-            }
-            return result;
+            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);
                 }
@@ -34,76 +120,86 @@ function createComponentMetaChecker(tsconfigPath) {
     const program = tsLs.getProgram();
     const typeChecker = program.getTypeChecker();
     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';
+    }
     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 : [];
         return {
             props: getProps(),
             events: getEvents(),
             slots: getSlots(),
+            exposed: getExposed(),
         };
         function getProps() {
             const $props = symbolProperties.find(prop => prop.escapedName === '$props');
+            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();
+                const { resolveSymbolSchema } = createSchemaResolvers(typeChecker, symbolNode);
+                result = properties.map(resolveSymbolSchema);
             }
-            return [];
+            // 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];
+                    }
+                }
+            }
+            return result;
         }
         function getEvents() {
             const $emit = symbolProperties.find(prop => prop.escapedName === '$emit');
             if ($emit) {
                 const type = typeChecker.getTypeOfSymbolAtLocation($emit, symbolNode);
                 const calls = type.getCallSignatures();
+                const { resolveSchema } = createSchemaResolvers(typeChecker, symbolNode);
                 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)),
+                    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 [];
@@ -116,15 +212,93 @@ function createComponentMetaChecker(tsconfigPath) {
                 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)),
+                    name: prop.getName(),
+                    type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(typeChecker.getTypeOfSymbolAtLocation(prop, symbolNode).getCallSignatures()[0].parameters[0], symbolNode)),
+                    description: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
+                }));
+            }
+            return [];
+        }
+        function getExposed() {
+            const exposed = symbolProperties.filter(prop => 
+            // 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 [];
         }
     }
+    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 findCmponentDefaultProps(componentPath) {
+    const fileText = ts.sys.readFile(componentPath);
+    if (fileText === undefined) {
+        throw new Error(`${componentPath} not found`);
+    }
+    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 findObjectLiteralExpression(node) {
+            if (ts.isObjectLiteralExpression(node)) {
+                return node;
+            }
+            let result;
+            node.forEachChild(child => {
+                if (!result) {
+                    result = findObjectLiteralExpression(child);
+                }
+            });
+            return result;
+        }
+    }
+    return result;
+}
+exports.findCmponentDefaultProps = findCmponentDefaultProps;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "vue-component-meta",
-	"version": "0.39.0",
+	"version": "0.39.2",
 	"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.2"
 	},
 	"peerDependencies": {
 		"typescript": "*"
-	}
+	},
+	"gitHead": "eac2dca4206dfa3f92ad50dd53650f924a9e6f94"
 }