1/* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import { 17 isCallSignatureDeclaration, isConstructSignatureDeclaration, isHeritageClause, isIndexSignatureDeclaration, 18 isMethodSignature, isPropertySignature, isTypeParameterDeclaration 19} from 'typescript'; 20import type { InterfaceDeclaration, SourceFile } from 'typescript'; 21import { getExportKeyword } from '../common/commonUtils'; 22import { getCallSignatureDeclaration } from './callSignatureDeclaration'; 23import type { CallSignatureEntity } from './callSignatureDeclaration'; 24import { getConstructorDeclaration } from './constructorDeclaration'; 25import type { ConstructorEntity } from './constructorDeclaration'; 26import { getHeritageClauseDeclaration } from './heritageClauseDeclaration'; 27import type { HeritageClauseEntity } from './heritageClauseDeclaration'; 28import { getIndexSignatureDeclaration } from './indexSignatureDeclaration'; 29import type { IndexSignatureEntity } from './indexSignatureDeclaration'; 30import { getMethodSignatureDeclaration } from './methodSignatureDeclaration'; 31import type { MethodSignatureEntity } from './methodSignatureDeclaration'; 32import { getPropertySignatureDeclaration } from './propertySignatureDeclaration'; 33import type { PropertySignatureEntity } from './propertySignatureDeclaration'; 34import { getTypeParameterDeclaration } from './typeParameterDeclaration'; 35import type { TypeParameterEntity } from './typeParameterDeclaration'; 36 37/** 38 * get interface info 39 * @param interfaceNode 40 * @param sourceFile 41 * @returns 42 */ 43export function getInterfaceDeclaration(interfaceNode: InterfaceDeclaration, sourceFile: SourceFile): InterfaceEntity { 44 let exportModifiers: Array<number> = []; 45 if (interfaceNode.modifiers !== undefined) { 46 exportModifiers = getExportKeyword(interfaceNode.modifiers); 47 } 48 49 const interfaceName = interfaceNode.name.escapedText.toString(); 50 const heritageClauses: Array<HeritageClauseEntity> = []; 51 const interfaceConstructors: Array<Array<ConstructorEntity>> = []; 52 const interfaceMethodSignature: Map<string, Array<MethodSignatureEntity>> = new Map<string, Array<MethodSignatureEntity>>(); 53 const interfacePropertySignatures: Array<PropertySignatureEntity> = []; 54 const callSignature: Array<CallSignatureEntity> = []; 55 const typeParameters: Array<TypeParameterEntity> = []; 56 const indexSignature: Array<IndexSignatureEntity> = []; 57 58 if (interfaceNode.heritageClauses !== undefined) { 59 interfaceNode.heritageClauses.forEach(value => { 60 heritageClauses.push(getHeritageClauseDeclaration(value, sourceFile)); 61 }); 62 } 63 64 interfaceNode.members.forEach(value => { 65 if (isPropertySignature(value)) { 66 interfacePropertySignatures.push(getPropertySignatureDeclaration(value, sourceFile)); 67 } else if (isMethodSignature(value)) { 68 const methodSignature = getMethodSignatureDeclaration(value, sourceFile); 69 if (interfaceMethodSignature.get(methodSignature.functionName) !== undefined) { 70 interfaceMethodSignature.get(methodSignature.functionName)?.push(methodSignature); 71 } else { 72 const methodSignatureArray: Array<MethodSignatureEntity> = []; 73 methodSignatureArray.push(methodSignature); 74 interfaceMethodSignature.set(methodSignature.functionName, methodSignatureArray); 75 } 76 } else if (isHeritageClause(value)) { 77 heritageClauses.push(getHeritageClauseDeclaration(value, sourceFile)); 78 } else if (isConstructSignatureDeclaration(value)) { 79 interfaceConstructors.push(getConstructorDeclaration(value, sourceFile)); 80 } else if (isCallSignatureDeclaration(value)) { 81 callSignature.push(getCallSignatureDeclaration(value, sourceFile)); 82 } else if (isTypeParameterDeclaration(value)) { 83 typeParameters.push(getTypeParameterDeclaration(value, sourceFile)); 84 } else if (isIndexSignatureDeclaration(value)) { 85 indexSignature.push(getIndexSignatureDeclaration(value, sourceFile)); 86 } else { 87 console.log('--------------------------- uncaught interface type start -----------------------'); 88 console.log('interfaceName: ' + interfaceName); 89 console.log(value); 90 console.log('--------------------------- uncaught interface type end -----------------------'); 91 } 92 }); 93 94 return { 95 interfaceName: interfaceName, 96 typeParameters: typeParameters, 97 heritageClauses: heritageClauses, 98 interfaceConstructors: interfaceConstructors, 99 interfaceMethodSignature: interfaceMethodSignature, 100 interfacePropertySignatures: interfacePropertySignatures, 101 callSignatures: callSignature, 102 exportModifiers: exportModifiers, 103 indexSignature: indexSignature 104 }; 105} 106 107export interface InterfaceEntity { 108 interfaceName: string, 109 typeParameters: Array<TypeParameterEntity>, 110 heritageClauses: Array<HeritageClauseEntity>, 111 interfaceConstructors: Array<Array<ConstructorEntity>>, 112 interfaceMethodSignature: Map<string, Array<MethodSignatureEntity>>, 113 interfacePropertySignatures: Array<PropertySignatureEntity>, 114 callSignatures: Array<CallSignatureEntity>, 115 exportModifiers: Array<number>, 116 indexSignature: Array<IndexSignatureEntity> 117} 118