vue-component-meta 3.1.8 → 3.2.0

package/lib/schemaResolvers.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchemaResolvers = createSchemaResolvers;
+const scriptSetup_1 = require("./scriptSetup");
+const publicPropsInterfaces = new Set([
+    'PublicProps',
+    'VNodeProps',
+    'AllowedComponentProps',
+    'ComponentCustomProps',
+]);
+function createSchemaResolvers(ts, typeChecker, printer, language, options, deprecatedOptions) {
+    const visited = new Set();
+    function shouldIgnore(subtype) {
+        const name = getFullyQualifiedName(subtype);
+        if (name === 'any') {
+            return true;
+        }
+        if (visited.has(subtype)) {
+            return true;
+        }
+        if (options === false) {
+            return true;
+        }
+        if (typeof options === 'object') {
+            for (const item of options.ignore ?? []) {
+                if (typeof item === 'function') {
+                    const result = item(name, subtype, typeChecker);
+                    if (typeof result === 'boolean') {
+                        return result;
+                    }
+                }
+                else if (name === item) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    function reducer(acc, cur) {
+        acc[cur.name] = cur;
+        return acc;
+    }
+    function getJsDocTags(target) {
+        return target.getJsDocTags(typeChecker).map(tag => ({
+            name: tag.name,
+            text: tag.text !== undefined ? ts.displayPartsToString(tag.text) : undefined,
+        }));
+    }
+    function resolveNestedProperties(propSymbol) {
+        const subtype = typeChecker.getTypeOfSymbol(propSymbol);
+        let schema;
+        let declarations;
+        let global = false;
+        let _default;
+        let required = !(propSymbol.flags & ts.SymbolFlags.Optional);
+        for (const decl of propSymbol.declarations ?? []) {
+            if (isPublicProp(decl)) {
+                global = true;
+            }
+            if (ts.isPropertyAssignment(decl) && ts.isObjectLiteralExpression(decl.initializer)) {
+                for (const option of decl.initializer.properties) {
+                    if (ts.isPropertyAssignment(option)) {
+                        const key = option.name.getText();
+                        if (key === 'default') {
+                            const defaultExp = (0, scriptSetup_1.resolveDefaultOptionExpression)(ts, option.initializer);
+                            _default = printer.printNode(ts.EmitHint.Expression, defaultExp, decl.getSourceFile());
+                        }
+                        else if (key === 'required') {
+                            if (option.initializer.getText() === 'true') {
+                                required = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            name: propSymbol.getEscapedName().toString(),
+            global,
+            default: _default,
+            description: ts.displayPartsToString(propSymbol.getDocumentationComment(typeChecker)),
+            tags: getJsDocTags(propSymbol),
+            required,
+            type: getFullyQualifiedName(subtype),
+            get schema() {
+                return schema ??= resolveSchema(subtype);
+            },
+            get declarations() {
+                if (deprecatedOptions.noDeclarations) {
+                    return [];
+                }
+                return this.getDeclarations();
+            },
+            get rawType() {
+                if (deprecatedOptions.rawType) {
+                    return this.getTypeObject();
+                }
+            },
+            getDeclarations() {
+                return declarations ??= getDeclarations(propSymbol.declarations ?? []);
+            },
+            getTypeObject() {
+                return subtype;
+            },
+        };
+    }
+    function isPublicProp(declaration) {
+        let parent = declaration.parent;
+        while (parent) {
+            if (ts.isInterfaceDeclaration(parent) || ts.isTypeAliasDeclaration(parent)) {
+                if (publicPropsInterfaces.has(parent.name.text)) {
+                    return true;
+                }
+                return false;
+            }
+            parent = parent.parent;
+        }
+        return false;
+    }
+    function resolveSlotProperties(prop) {
+        const propType = typeChecker.getNonNullableType(typeChecker.getTypeOfSymbol(prop));
+        const signatures = propType.getCallSignatures();
+        const paramType = signatures[0]?.parameters[0];
+        const subtype = paramType
+            ? typeChecker.getTypeOfSymbol(paramType)
+            : typeChecker.getAnyType();
+        let schema;
+        let declarations;
+        return {
+            name: prop.getName(),
+            type: getFullyQualifiedName(subtype),
+            description: ts.displayPartsToString(prop.getDocumentationComment(typeChecker)),
+            tags: getJsDocTags(prop),
+            get schema() {
+                return schema ??= resolveSchema(subtype);
+            },
+            get declarations() {
+                if (deprecatedOptions.noDeclarations) {
+                    return [];
+                }
+                return this.getDeclarations();
+            },
+            get rawType() {
+                if (deprecatedOptions.rawType) {
+                    return this.getTypeObject();
+                }
+            },
+            getDeclarations() {
+                return declarations ??= getDeclarations(prop.declarations ?? []);
+            },
+            getTypeObject() {
+                return subtype;
+            },
+        };
+    }
+    function resolveExposedProperties(expose) {
+        const subtype = typeChecker.getTypeOfSymbol(expose);
+        let schema;
+        let declarations;
+        return {
+            name: expose.getName(),
+            type: getFullyQualifiedName(subtype),
+            description: ts.displayPartsToString(expose.getDocumentationComment(typeChecker)),
+            tags: getJsDocTags(expose),
+            get schema() {
+                return schema ??= resolveSchema(subtype);
+            },
+            get declarations() {
+                if (deprecatedOptions.noDeclarations) {
+                    return [];
+                }
+                return this.getDeclarations();
+            },
+            get rawType() {
+                if (deprecatedOptions.rawType) {
+                    return this.getTypeObject();
+                }
+            },
+            getDeclarations() {
+                return declarations ??= getDeclarations(expose.declarations ?? []);
+            },
+            getTypeObject() {
+                return subtype;
+            },
+        };
+    }
+    function resolveEventSignature(call) {
+        let schema;
+        let declarations;
+        let subtype;
+        let symbol;
+        let subtypeStr = '[]';
+        let getSchema = () => [];
+        if (call.parameters.length >= 2) {
+            symbol = call.parameters[1];
+            subtype = typeChecker.getTypeOfSymbol(symbol);
+            if (call.parameters[1].valueDeclaration?.dotDotDotToken) {
+                subtypeStr = getFullyQualifiedName(subtype);
+                getSchema = () => typeChecker.getTypeArguments(subtype).map(resolveSchema);
+            }
+            else {
+                subtypeStr = '[';
+                for (let i = 1; i < call.parameters.length; i++) {
+                    subtypeStr += getFullyQualifiedName(typeChecker.getTypeOfSymbol(call.parameters[i]))
+                        + ', ';
+                }
+                subtypeStr = subtypeStr.slice(0, -2) + ']';
+                getSchema = () => {
+                    const result = [];
+                    for (let i = 1; i < call.parameters.length; i++) {
+                        result.push(resolveSchema(typeChecker.getTypeOfSymbol(call.parameters[i])));
+                    }
+                    return result;
+                };
+            }
+        }
+        return {
+            name: typeChecker.getTypeOfSymbol(call.parameters[0]).value,
+            description: ts.displayPartsToString(call.getDocumentationComment(typeChecker)),
+            tags: getJsDocTags(call),
+            type: subtypeStr,
+            signature: typeChecker.signatureToString(call),
+            get schema() {
+                return schema ??= getSchema();
+            },
+            get declarations() {
+                if (deprecatedOptions.noDeclarations) {
+                    return [];
+                }
+                return this.getDeclarations();
+            },
+            get rawType() {
+                if (deprecatedOptions.rawType) {
+                    return this.getTypeObject();
+                }
+            },
+            getDeclarations() {
+                return declarations ??= call.declaration ? getDeclarations([call.declaration]) : [];
+            },
+            getTypeObject() {
+                return subtype;
+            },
+        };
+    }
+    function resolveCallbackSchema(signature) {
+        let schema;
+        return {
+            kind: 'event',
+            type: typeChecker.signatureToString(signature),
+            get schema() {
+                return schema ??= signature.parameters.length
+                    ? typeChecker
+                        .getTypeArguments(typeChecker.getTypeOfSymbol(signature.parameters[0]))
+                        .map(resolveSchema)
+                    : undefined;
+            },
+        };
+    }
+    function resolveSchema(subtype) {
+        const type = getFullyQualifiedName(subtype);
+        if (shouldIgnore(subtype)) {
+            return type;
+        }
+        visited.add(subtype);
+        if (subtype.isUnion()) {
+            let schema;
+            return {
+                kind: 'enum',
+                type,
+                get schema() {
+                    return schema ??= subtype.types.map(resolveSchema);
+                },
+            };
+        }
+        else if (typeChecker.isArrayLikeType(subtype)) {
+            let schema;
+            return {
+                kind: 'array',
+                type,
+                get schema() {
+                    return schema ??= typeChecker.getTypeArguments(subtype).map(resolveSchema);
+                },
+            };
+        }
+        else if (subtype.getCallSignatures().length === 0
+            && (subtype.isClassOrInterface() || subtype.isIntersection()
+                || subtype.objectFlags & ts.ObjectFlags.Anonymous)) {
+            let schema;
+            return {
+                kind: 'object',
+                type,
+                get schema() {
+                    return schema ??= subtype.getProperties().map(resolveNestedProperties).reduce(reducer, {});
+                },
+            };
+        }
+        else if (subtype.getCallSignatures().length === 1) {
+            return resolveCallbackSchema(subtype.getCallSignatures()[0]);
+        }
+        return type;
+    }
+    function getFullyQualifiedName(type) {
+        const str = typeChecker.typeToString(type, undefined, ts.TypeFormatFlags.UseFullyQualifiedType | ts.TypeFormatFlags.NoTruncation);
+        if (str.includes('import(')) {
+            return str.replace(/import\(.*?\)\./g, '');
+        }
+        return str;
+    }
+    function getDeclarations(declaration) {
+        return declaration.map(getDeclaration).filter(d => !!d);
+    }
+    function getDeclaration(declaration) {
+        const fileName = declaration.getSourceFile().fileName;
+        const sourceScript = language.scripts.get(fileName);
+        if (sourceScript?.generated) {
+            const script = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+            if (script) {
+                for (const [sourceScript, map] of language.maps.forEach(script.code)) {
+                    for (const [start] of map.toSourceLocation(declaration.getStart())) {
+                        for (const [end] of map.toSourceLocation(declaration.getEnd())) {
+                            return {
+                                file: sourceScript.id,
+                                range: [start, end],
+                            };
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        return {
+            file: declaration.getSourceFile().fileName,
+            range: [declaration.getStart(), declaration.getEnd()],
+        };
+    }
+    return {
+        resolveNestedProperties,
+        resolveSlotProperties,
+        resolveEventSignature,
+        resolveExposedProperties,
+        resolveSchema,
+    };
+}
+//# sourceMappingURL=schemaResolvers.js.map

package/lib/scriptSetup.d.ts

@@ -0,0 +1,4 @@
+import * as core from '@vue/language-core';
+import type * as ts from 'typescript';
+export declare function getDefaultsFromScriptSetup(ts: typeof import('typescript'), printer: ts.Printer, language: core.Language<string>, componentPath: string): Map<string, string> | undefined;
+export declare function resolveDefaultOptionExpression(ts: typeof import('typescript'), _default: ts.Expression): ts.Expression;

package/lib/scriptSetup.js

@@ -0,0 +1,133 @@
+"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.getDefaultsFromScriptSetup = getDefaultsFromScriptSetup;
+exports.resolveDefaultOptionExpression = resolveDefaultOptionExpression;
+const core = __importStar(require("@vue/language-core"));
+function getDefaultsFromScriptSetup(ts, printer, language, componentPath) {
+    const sourceScript = language.scripts.get(componentPath);
+    const virtualCode = sourceScript?.generated?.root;
+    if (!virtualCode) {
+        return;
+    }
+    const sourceFile = virtualCode.sfc.scriptSetup?.ast;
+    if (!sourceFile) {
+        return;
+    }
+    const scriptSetupRanges = core.parseScriptSetupRanges(ts, sourceFile, virtualCode.vueCompilerOptions);
+    if (scriptSetupRanges) {
+        return collectPropDefaultsFromScriptSetup(ts, printer, sourceFile, scriptSetupRanges);
+    }
+}
+function collectPropDefaultsFromScriptSetup(ts, printer, sourceFile, scriptSetupRanges) {
+    const result = new Map();
+    if (scriptSetupRanges.withDefaults?.arg) {
+        const obj = findObjectLiteralExpression(ts, scriptSetupRanges.withDefaults.arg.node);
+        if (obj) {
+            for (const prop of obj.properties) {
+                if (ts.isPropertyAssignment(prop)) {
+                    const name = prop.name.getText(sourceFile);
+                    const expNode = resolveDefaultOptionExpression(ts, prop.initializer);
+                    const expText = printer.printNode(ts.EmitHint.Expression, expNode, sourceFile);
+                    result.set(name, expText);
+                }
+            }
+        }
+    }
+    else if (scriptSetupRanges.defineProps?.destructured) {
+        for (const [name, initializer] of scriptSetupRanges.defineProps.destructured) {
+            if (initializer) {
+                const expText = printer.printNode(ts.EmitHint.Expression, initializer, sourceFile);
+                result.set(name, expText);
+            }
+        }
+    }
+    if (scriptSetupRanges.defineModel) {
+        for (const defineModel of scriptSetupRanges.defineModel) {
+            const obj = defineModel.arg ? findObjectLiteralExpression(ts, defineModel.arg.node) : undefined;
+            if (obj) {
+                const name = defineModel.name
+                    ? sourceFile.text.slice(defineModel.name.start, defineModel.name.end).slice(1, -1)
+                    : 'modelValue';
+                const _default = resolveModelOption(ts, printer, sourceFile, obj);
+                if (_default) {
+                    result.set(name, _default);
+                }
+            }
+        }
+    }
+    return result;
+}
+function findObjectLiteralExpression(ts, node) {
+    if (ts.isObjectLiteralExpression(node)) {
+        return node;
+    }
+    let result;
+    node.forEachChild(child => {
+        if (!result) {
+            result = findObjectLiteralExpression(ts, child);
+        }
+    });
+    return result;
+}
+function resolveModelOption(ts, printer, sourceFile, options) {
+    let _default;
+    for (const prop of options.properties) {
+        if (ts.isPropertyAssignment(prop)) {
+            const name = prop.name.getText(sourceFile);
+            if (name === 'default') {
+                const expNode = resolveDefaultOptionExpression(ts, prop.initializer);
+                const expText = printer.printNode(ts.EmitHint.Expression, expNode, sourceFile) ?? expNode.getText(sourceFile);
+                _default = expText;
+            }
+        }
+    }
+    return _default;
+}
+function resolveDefaultOptionExpression(ts, _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=scriptSetup.js.map

package/lib/types.d.ts

@@ -1,5 +1,5 @@
 import type * as ts from 'typescript';
-export type ComponentMetaChecker = ReturnType<typeof import('./base')['createCheckerBase']>;
+export type ComponentMetaChecker = ReturnType<typeof import('./checker')['createCheckerBase']>;
 export interface Declaration {
     file: string;
     range: [number, number];
@@ -20,21 +20,25 @@ export declare enum TypeMeta {
 }
 export interface PropertyMeta {
     name: string;
-    default?: string;
     description: string;
+    type: string;
+    default?: string;
     global: boolean;
     required: boolean;
-    type: string;
     tags: {
         name: string;
         text?: string;
     }[];
-    declarations: Declaration[];
     schema: PropertyMetaSchema;
+    /**
+     * @deprecated use `getDeclarations()` instead
+     */
+    declarations: Declaration[];
     /**
      * @deprecated use `getTypeObject()` instead
      */
     rawType?: ts.Type;
+    getDeclarations(): Declaration[];
     getTypeObject(): ts.Type;
 }
 export interface EventMeta {
@@ -46,36 +50,56 @@ export interface EventMeta {
         name: string;
         text?: string;
     }[];
-    declarations: Declaration[];
     schema: PropertyMetaSchema[];
+    /**
+     * @deprecated use `getDeclarations()` instead
+     */
+    declarations: Declaration[];
     /**
      * @deprecated use `getTypeObject()` instead
      */
     rawType?: ts.Type;
+    getDeclarations(): Declaration[];
     getTypeObject(): ts.Type | undefined;
 }
 export interface SlotMeta {
     name: string;
-    type: string;
     description: string;
-    declarations: Declaration[];
+    type: string;
+    tags: {
+        name: string;
+        text?: string;
+    }[];
     schema: PropertyMetaSchema;
+    /**
+     * @deprecated use `getDeclarations()` instead
+     */
+    declarations: Declaration[];
     /**
      * @deprecated use `getTypeObject()` instead
      */
     rawType?: ts.Type;
+    getDeclarations(): Declaration[];
     getTypeObject(): ts.Type;
 }
 export interface ExposeMeta {
     name: string;
     description: string;
     type: string;
-    declarations: Declaration[];
+    tags: {
+        name: string;
+        text?: string;
+    }[];
     schema: PropertyMetaSchema;
+    /**
+     * @deprecated use `getDeclarations()` instead
+     */
+    declarations: Declaration[];
     /**
      * @deprecated use `getTypeObject()` instead
      */
     rawType?: ts.Type;
+    getDeclarations(): Declaration[];
     getTypeObject(): ts.Type;
 }
 export type PropertyMetaSchema = string | {
@@ -104,9 +128,15 @@ export type MetaCheckerSchemaOptions = boolean | {
 };
 export interface MetaCheckerOptions {
     schema?: MetaCheckerSchemaOptions;
-    forceUseTs?: boolean;
     printer?: ts.PrinterOptions;
+    /**
+     * @deprecated No longer needed, this is default behavior now
+     */
     noDeclarations?: boolean;
+    /**
+     * @deprecated No longer needed, this is default behavior now
+     */
+    forceUseTs?: boolean;
     /**
      * @deprecated No longer needed, use `getTypeObject()` instead
      */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "vue-component-meta",
-	"version": "3.1.8",
+	"version": "3.2.0",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,17 +13,21 @@
 		"directory": "packages/component-meta"
 	},
 	"dependencies": {
-		"@volar/typescript": "2.4.26",
-		"@vue/language-core": "3.1.8",
-		"path-browserify": "^1.0.1",
-		"vue-component-type-helpers": "3.1.8"
-	},
-	"peerDependencies": {
-		"typescript": "*"
+		"@volar/typescript": "2.4.27",
+		"@vue/language-core": "3.2.0",
+		"path-browserify": "^1.0.1"
 	},
 	"devDependencies": {
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1"
 	},
-	"gitHead": "0c9b66d0332698a1764fa56b64d47a6a30e81b47"
+	"peerDependencies": {
+		"typescript": "*"
+	},
+	"peerDependenciesMeta": {
+		"typescript": {
+			"optional": true
+		}
+	},
+	"gitHead": "3138110d767d3d6110899bc46518b53c4b456271"
 }

package/lib/base.d.ts

@@ -1,33 +0,0 @@
-import type * as ts from 'typescript';
-import type { ComponentMeta, MetaCheckerOptions } from './types';
-export * from './types';
-export declare function createCheckerByJsonConfigBase(ts: typeof import('typescript'), rootDir: string, json: any, checkerOptions?: MetaCheckerOptions): {
-    getExportNames: (componentPath: string) => string[];
-    getComponentMeta: (componentPath: string, exportName?: string) => ComponentMeta;
-    updateFile(fileName: string, text: string): void;
-    deleteFile(fileName: string): void;
-    reload(): void;
-    clearCache(): void;
-    getProgram(): ts.Program | undefined;
-    /**
-     * @deprecated use `getProgram()` instead
-     */
-    __internal__: {
-        tsLs: ts.LanguageService;
-    };
-};
-export declare function createCheckerBase(ts: typeof import('typescript'), tsconfig: string, checkerOptions?: MetaCheckerOptions): {
-    getExportNames: (componentPath: string) => string[];
-    getComponentMeta: (componentPath: string, exportName?: string) => ComponentMeta;
-    updateFile(fileName: string, text: string): void;
-    deleteFile(fileName: string): void;
-    reload(): void;
-    clearCache(): void;
-    getProgram(): ts.Program | undefined;
-    /**
-     * @deprecated use `getProgram()` instead
-     */
-    __internal__: {
-        tsLs: ts.LanguageService;
-    };
-};