Function computePropertiesForLiteralType

src/telemetryGenerator.node.ts:127–281

(literalType: ts.TypeLiteralNode, typeChecker: ts.TypeChecker)

};

function computePropertiesForLiteralType(literalType: ts.TypeLiteralNode, typeChecker: ts.TypeChecker) {
    const properties: TelemetryProperty[] = [];

    literalType.members.forEach((m) => {
        if (m.kind === ts.SyntaxKind.PropertySignature && ts.isPropertySignature(m)) {
            const name = m.name.getText();
            const anyM = m as unknown as { jsDoc?: { comment: string }[] };
            const descriptions = Array.isArray(anyM.jsDoc) ? anyM.jsDoc[0].comment.split(/\r?\n/) || [] : [];
            let possibleValues: { value: string; comment?: string | string[] }[] = [];
            let typeValue = '';
            if (
                (m.type?.kind === ts.SyntaxKind.TypeReference && ts.isTypeReferenceNode(m.type)) ||
                (m.type?.kind === ts.SyntaxKind.UnionType && ts.isUnionTypeNode(m.type))
            ) {
                const type = typeChecker.getTypeAtLocation(m.type);
                if (type.isUnion()) {
                    const isEnum = type
                        .getSymbol()
                        ?.getDeclarations()
                        ?.some((d) => d.kind === ts.SyntaxKind.EnumDeclaration);
                    const enumName = type.getSymbol()?.escapedName;
                    type.types.forEach((t) => {
                        if (t.isLiteral()) {
                            const value = t.value.toString();
                            const declaration = t.symbol?.declarations?.length
                                ? (t.symbol.declarations[0] as unknown as { jsDoc?: { comment: string }[] })
                                : undefined;
                            const comment = [];
                            if (isEnum && parseInt(value, 10).toString() === value.trim()) {
                                comment.push(`Enum Member: ${enumName}.${t.symbol.escapedName}`);
                            }
                            if (declaration && Array.isArray(declaration.jsDoc) && declaration.jsDoc.length > 0) {
                                comment.push(declaration.jsDoc[0].comment);
                            }
                            possibleValues.push({ value, comment });
                        }
                    });
                }
                const mType = m.type;
                if (
                    mType.kind === ts.SyntaxKind.UnionType &&
                    ts.isUnionTypeNode(mType) &&
                    possibleValues.every((item) => (item.comment || '').length === 0)
                ) {
                    // Support comments in union string literals.
                    const newPossibleValues: { value: string; comment?: string | string[] }[] = [];
                    mType.types.forEach((t) => {
                        if (t.kind === ts.SyntaxKind.LiteralType) {
                            const value = t.getText();
                            const comment = getCommentForUnions(t);
                            newPossibleValues.push({ value, comment });
                        } else if (t.kind === ts.SyntaxKind.NullKeyword || t.kind === ts.SyntaxKind.UndefinedKeyword) {
                            newPossibleValues.push({ value: 'null or <empty>', comment: '' });
                        } else if (t.kind === ts.SyntaxKind.BooleanKeyword) {
                            newPossibleValues.push({ value: 'true', comment: '' });
                            newPossibleValues.push({ value: 'false', comment: '' });
                        }
                    });