Function handleMember

packages/alphatab/scripts/TypeSchema.ts:39–89

(
        member: ts.ClassDeclaration['members'][0],
        typeArgumentMapping: Map<string, ts.Type> | undefined
    )

    };

    const handleMember = (
        member: ts.ClassDeclaration['members'][0],
        typeArgumentMapping: Map<string, ts.Type> | undefined
    ) => {
        if (ts.isPropertyDeclaration(member)) {
            const propertyDeclaration = member as ts.PropertyDeclaration;
            if (
                !propertyDeclaration.modifiers!.find(
                    m => m.kind === ts.SyntaxKind.StaticKeyword || m.kind === ts.SyntaxKind.PrivateKeyword
                )
            ) {
                const jsonNames = [(member.name as ts.Identifier).text.toLowerCase()];
                const jsDoc = ts.getJSDocTags(member);

                if (jsDoc.find(t => t.tagName.text === 'json_on_parent')) {
                    jsonNames.push('');
                }

                if (!jsDoc.find(t => t.tagName.text === 'json_ignore')) {
                    const asRaw = !!jsDoc.find(t => t.tagName.text === 'json_raw');
                    const isReadonly = !!jsDoc.find(t => t.tagName.text === 'json_read_only');
                    schema.properties.push({
                        jsonNames: jsonNames,
                        asRaw,
                        partialNames: !!jsDoc.find(t => t.tagName.text === 'json_partial_names'),
                        target: jsDoc.find(t => t.tagName.text === 'target')?.comment as string,
                        isJsonReadOnly: isReadonly,
                        isReadOnly: propertyDeclaration.modifiers!.some(m => m.kind == ts.SyntaxKind.ReadonlyKeyword),
                        name: (member.name as ts.Identifier).text,
                        jsDocTags: jsDoc,
                        type: getTypeWithNullableInfo(
                            program,
                            member.type ?? program.getTypeChecker().getTypeAtLocation(member.name),
                            asRaw || isReadonly,
                            !!member.questionToken,
                            typeArgumentMapping
                        )
                    });
                }
            }
        } else if (ts.isMethodDeclaration(member)) {
            switch ((member.name as ts.Identifier).text) {
                case 'toJson':
                    schema.hasToJsonExtension = true;
                    break;
                case 'setProperty':
                    schema.hasSetPropertyExtension = true;
                    break;
            }
        }
    };

    let hierarchy: ts.ClassDeclaration | undefined = input;
    let typeArgumentMapping: Map<string, ts.Type> | undefined;