Function generateDocumentation

src/telemetryGenerator.node.ts:432–608

(fileNames: string[])

}

function generateDocumentation(fileNames: string[]): void {
    const configFile = getTsCompilerOptionsJson();
    const host = new TypeScriptLanguageServiceHost(fileNames, configFile.options);
    const languageService = ts.createLanguageService(host, undefined, ts.LanguageServiceMode.Semantic);
    const program = languageService.getProgram()!;
    const typeChecker = program!.getTypeChecker();
    const entries = new Map<string, TelemetryEntry>();

    // First generate documentation for common properties and measures.
    generateDocumentationForCommonTypes(fileNames);

    // Visit every sourceFile in the program
    if (program) {
        for (const sourceFile of program.getSourceFiles()) {
            if (!sourceFile.isDeclarationFile) {
                // Walk the tree to search for classes
                ts.forEachChild(sourceFile, visit.bind(undefined, sourceFile));
            }
        }
    }
    /** visit nodes finding exported classes */
    function visit(sourceFile: ts.SourceFile, node: ts.Node) {
        // Only consider exported nodes
        if (!isNodeExported(node)) {
            return;
        }
        if (ts.isModuleDeclaration(node)) {
            // This is a namespace, visit its children
            ts.forEachChild(node, visit.bind(undefined, sourceFile));
            return;
        }

        if (!ts.isClassDeclaration(node) || node.name?.text !== 'IEventNamePropertyMapping') {
            return;
        }

        try {
            node.members.forEach((m) => {
                if (ts.isPropertyDeclaration(m)) {
                    const typeNode = m.type;
                    if (!typeNode || typeNode.kind !== ts.SyntaxKind.TypeReference) {
                        console.error(`Unrecognized type ${m.name.getText()}`);
                    } else if (
                        typeNode &&
                        ts.isTypeReferenceNode(typeNode) &&
                        typeNode.typeArguments?.length === 1 &&
                        typeNode.typeName.getText() === 'TelemetryEventInfo'
                    ) {
                        let name = m.name.getText().trim();
                        let constantName = m.name.getText().trim().replace('[', '').replace(']', '');

                        if (m.name.kind === ts.SyntaxKind.ComputedPropertyName) {
                            const defs = languageService.getDefinitionAtPosition(
                                m.getSourceFile().fileName,
                                m.name.end - 1
                            );
                            if (defs && defs.length) {
                                const refSourceFile = program!.getSourceFile(defs[0].fileName);