• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 ts from 'typescript';
17
18import { Comment } from '../../typedef/parser/Comment';
19import { StringConstant } from '../../utils/Constant';
20import {
21  ApiInfo,
22  ApiType,
23  BasicApiInfo,
24  ContainerApiInfo,
25  containerApiTypes,
26  ClassInfo,
27  ConstantInfo,
28  EnumInfo,
29  EnumValueInfo,
30  ExportDeclareInfo,
31  ExportDefaultInfo,
32  ExportImportValue,
33  ImportInfo,
34  InterfaceInfo,
35  MethodInfo,
36  MethodType,
37  ModifierProcessorInterface,
38  ModuleInfo,
39  NamespaceInfo,
40  NodeProcessorInterface,
41  ParamInfo,
42  PropertyInfo,
43  PropertyNode,
44  TypeAliasInfo,
45  TypeAliasType,
46} from '../../typedef/parser/ApiInfoDefination';
47import * as ResultsInfo from '../../typedef/parser/ResultsInfo';
48import { ApiInfosMap, BasicApiInfoMap, FileInfoMap, FilesMap } from './parser';
49
50/**
51 * 处理解析完节点数据的方法
52 */
53export class ResultsProcessHelper {
54  // 如果是字符串的话，会出现单双引号重复的情况
55  static regQuotation: RegExp = /^[\'|\"](.*)[\'|\"]$/;
56  /**
57   * 获取fileMap里的对应的apiinfos
58   *
59   * @param { FileInfoMap } fileMap 文件解析结果
60   * @param { string } apiKey 获取api名称
61   * @return {BasicApiInfo[]} apiInfo
62   */
63  static getApiInfosInFileMap(fileMap: FileInfoMap, apiKey: string): BasicApiInfo[] {
64    if (apiKey === StringConstant.SELF) {
65      return [];
66    }
67    const apiInfoMap: ApiInfosMap = fileMap.get(apiKey) as ApiInfosMap;
68    return apiInfoMap.get(StringConstant.SELF) as BasicApiInfo[];
69  }
70
71  /**
72   * 获取SourceFile节点下的第一层节点解析后的对象
73   *
74   * @param { FileInfoMap } fileMap 获取到的一个文件解析到的map对象
75   * @return {BasicApiInfo[]}  SourceFile节点下的第一层节点解析后的对象
76   */
77  static processFileApiMap(fileMap: FileInfoMap): BasicApiInfo[] {
78    const apis: BasicApiInfo[] = [];
79    for (const apiKey of fileMap.keys()) {
80      const apiInfos: BasicApiInfo[] = ResultsProcessHelper.getApiInfosInFileMap(fileMap, apiKey);
81      apiInfos.forEach((apiInfo: BasicApiInfo) => {
82        ResultsProcessHelper.processApiInfo(apiInfo);
83        apis.push(apiInfo);
84      });
85    }
86    return apis;
87  }
88
89  /**
90   * 将每一个节点解析后的对象的parentApi属性置为undefined，防止循环引用
91   *
92   * @param { BasicApiInfo } basicApiInfo 解析后的api对象
93   */
94  static processApiInfo(basicApiInfo: BasicApiInfo): void {
95    basicApiInfo.setParentApi(undefined);
96    basicApiInfo.removeNode();
97    ResultsProcessHelper.processJsDocInfos(basicApiInfo as ApiInfo);
98    if (!containerApiTypes.has(basicApiInfo.getApiType())) {
99      return;
100    }
101    const containerApiInfo: ContainerApiInfo = basicApiInfo as ContainerApiInfo;
102    containerApiInfo.getChildApis().forEach((childApiInfo: BasicApiInfo) => {
103      ResultsProcessHelper.processApiInfo(childApiInfo);
104    });
105  }
106
107  /**
108   * 判断jsdoc节点，去除tag数组
109   *
110   * @param {ApiInfo} apiInfo
111   * @return {void}
112   */
113  static processJsDocInfos(apiInfo: ApiInfo): void {
114    if (!(apiInfo instanceof ApiInfo)) {
115      return;
116    }
117    const jsDocInfos: Comment.JsDocInfo[] = apiInfo.getJsDocInfos();
118    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
119      jsDocInfo.removeTags();
120    });
121  }
122
123  /**
124   * 解析整个文件所有api
125   *
126   * @param {FileInfoMap} fileMap 文件对象
127   * @return {BasicApiInfo[]} 整个文件的所有api
128   */
129  static processFileApiMapForGetBasicApi(fileMap: FileInfoMap): BasicApiInfo[] {
130    let apis: BasicApiInfo[] = [];
131    for (const apiKey of fileMap.keys()) {
132      const apiInfos: BasicApiInfo[] = ResultsProcessHelper.getApiInfosInFileMap(fileMap, apiKey);
133      apiInfos.forEach((apiInfo: BasicApiInfo) => {
134        apis = apis.concat(ResultsProcessHelper.processApiInfoForGetBasicApi(apiInfo));
135      });
136    }
137    return apis;
138  }
139
140  /**
141   * 获取一个api的所有子节点，例如NamespaceInfo | ClassInfo | InterfaceInfo | EnumInfo | ModuleInfo | StructInfo
142   *
143   * @param { BasicApiInfo } basicApiInfo 解析后的api对象
144   * @return { BasicApiInfo[] } 递归获取有子节点的api的所有api
145   */
146  static processApiInfoForGetBasicApi(basicApiInfo: BasicApiInfo): BasicApiInfo[] {
147    let apis: BasicApiInfo[] = [];
148    apis = apis.concat(basicApiInfo);
149    if (!containerApiTypes.has(basicApiInfo.getApiType())) {
150      return apis;
151    }
152    const containerApiInfo: ContainerApiInfo = basicApiInfo as ContainerApiInfo;
153    containerApiInfo.getChildApis().forEach((childApiInfo: BasicApiInfo) => {
154      apis = apis.concat(ResultsProcessHelper.processApiInfoForGetBasicApi(childApiInfo));
155    });
156    return apis;
157  }
158  /**
159   * 获取SourceFile节点下的第一层节点解析后的对象，需要将JsDoc按照since的版本进行拆分
160   * 1、子节点的since必须大于等于父节点的since，小于的进行剔除
161   * 2、一个节点出现多段JsDoc时，将会拆分成多个节点，每个节点包含对应版本的子节点
162   * 3、JsDoc中since默认为-1，可以存在一段没有since的JsDoc
163   * 3、当节点没有JsDoc时设置since默认为-1，其他信息默认
164   *
165   * @param { FileInfoMap } fileMap
166   * @return  { Array<Comment.jsDocEachSince> }
167   */
168  static processFileApiMapForEachSince(fileMap: FileInfoMap): Array<ResultsInfo.BasicApiInfo> {
169    const apis: ResultsInfo.BasicApiInfo[] = [];
170    for (const apiKey of fileMap.keys()) {
171      const apiInfos: BasicApiInfo[] = ResultsProcessHelper.getApiInfosInFileMap(fileMap, apiKey);
172      apiInfos.forEach((apiInfo: BasicApiInfo) => {
173        const api: ResultsInfo.BasicApiInfo[] = ResultsProcessHelper.processApiInfoForEachSince(apiInfo);
174        if (api.length === 0) {
175          return;
176        }
177        apis.push(...api);
178      });
179    }
180    return apis;
181  }
182
183  /**
184   * 获取到文件下每个节点的数据，解析jsdoc中的since信息，根据规则提取出对应数组
185   *
186   * @param {BasicApiInfo} basicApiInfo 一级节点信息
187   * @return {ResultsInfo.BasicApiInfo[]}
188   */
189  static processApiInfoForEachSince(basicApiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
190    const resultApis: ResultsInfo.BasicApiInfo[] = ResultsProcessHelper.getNodeInfo(basicApiInfo);
191    if (!containerApiTypes.has(basicApiInfo.getApiType())) {
192      return resultApis;
193    }
194    const containerApiInfo: ContainerApiInfo = basicApiInfo as ContainerApiInfo;
195    containerApiInfo.getChildApis().forEach((childApiInfo: BasicApiInfo) => {
196      const childApis: ResultsInfo.BasicApiInfo[] = ResultsProcessHelper.processApiInfoForEachSince(childApiInfo);
197      ResultsProcessHelper.mergeResultApis(resultApis, childApis);
198    });
199    return resultApis;
200  }
201
202  /**
203   * 根据父节点和子节点，将子节点中满足父节点的版本要求的数据填充到父节点
204   *
205   * @param {ResultsInfo.BasicApiInfo[]} parentApis 父节点信息，根据jsdoc分段
206   * @param {ResultsInfo.BasicApiInfo[]} childApis 子节点信息，根据jsdoc分段
207   */
208  static mergeResultApis(parentApis: ResultsInfo.BasicApiInfo[], childApis: ResultsInfo.BasicApiInfo[]): void {
209    parentApis.forEach((parentApi: ResultsInfo.BasicApiInfo) => {
210      const containerApiInfo: ResultsInfo.NamespaceEnumInfo = parentApi as ResultsInfo.NamespaceEnumInfo;
211      const cApis: ResultsInfo.BasicApiInfo[] = ResultsProcessHelper.getResultApisVersion(
212        childApis,
213        Number(containerApiInfo.getSince())
214      );
215      containerApiInfo.addChildApi(cApis);
216    });
217  }
218
219  /**
220   * 在多段jsdoc数据中提取符合版本的数据
221   *
222   * @param {ResultsInfo.BasicApiInfo[]} resultApis
223   * @param {number} version
224   * @return {ResultsInfo.BasicApiInfo[]}
225   */
226  static getResultApisVersion(resultApis: ResultsInfo.BasicApiInfo[], version: number): ResultsInfo.BasicApiInfo[] {
227    return resultApis.filter((resultApi: ResultsInfo.BasicApiInfo) => {
228      const apiInfo: ResultsInfo.ApiInfo = resultApi as ResultsInfo.ApiInfo;
229      const since: number = Number(apiInfo.getSince());
230      return since === -1 || since >= version;
231    });
232  }
233
234  /**
235   * 按节点的类型分类处理，拆分多段jsdoc
236   *
237   * @param {BasicApiInfo} apiInfo 节点信息
238   * @return {ResultsInfo.BasicApiInfo[]}
239   */
240  static getNodeInfo(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
241    let apiType: string = apiInfo.getApiType();
242    const nodeProcessor: ResultsInfo.NodeProcessorInterface | undefined = resultsProcessMethod.get(apiType);
243    if (!nodeProcessor) {
244      return [];
245    }
246    const newApiInfos: ResultsInfo.BasicApiInfo[] = nodeProcessor(apiInfo);
247    return newApiInfos;
248  }
249
250  static processProperty(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
251    const infos: ResultsInfo.PropertyInfo[] = [];
252    const propertyInfo: PropertyInfo = apiInfo as PropertyInfo;
253    const jsDocInfos: Comment.JsDocInfo[] = propertyInfo.getJsDocInfos();
254    if (jsDocInfos.length === 0) {
255      const newInfo: ResultsInfo.PropertyInfo = new ResultsInfo.PropertyInfo(
256        apiInfo.getApiType(),
257        new Comment.JsDocInfo()
258      );
259      newInfo.setType(propertyInfo.getType().join(' | '));
260      newInfo.setName(apiInfo.getApiName());
261      newInfo.setIsRequired(propertyInfo.getIsRequired());
262      newInfo.setIsReadOnly(propertyInfo.getIsReadOnly());
263      newInfo.setIsStatic(propertyInfo.getIsStatic());
264      infos.push(newInfo);
265    }
266    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
267      const newInfo: ResultsInfo.PropertyInfo = new ResultsInfo.PropertyInfo(apiInfo.getApiType(), jsDocInfo);
268      const typeInfo: string = jsDocInfo.getTypeInfo();
269      const isRequired: boolean = !/\?/.test(typeInfo);
270      newInfo.setType(typeInfo ? typeInfo.replace(/^[\?]*[\(](.*)[\)]$/, '$1') : propertyInfo.getType().join(' | '));
271      newInfo.setName(apiInfo.getApiName());
272      newInfo.setIsRequired(isRequired ? true : propertyInfo.getIsRequired());
273      newInfo.setIsReadOnly(propertyInfo.getIsReadOnly());
274      newInfo.setIsStatic(propertyInfo.getIsStatic());
275      infos.push(newInfo);
276    });
277    return infos;
278  }
279
280  static processClass(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
281    const infos: ResultsInfo.ClassInterfaceInfo[] = [];
282    const classInfo: ClassInfo = apiInfo as ClassInfo;
283    const jsDocInfos: Comment.JsDocInfo[] = classInfo.getJsDocInfos();
284    if (jsDocInfos.length === 0) {
285      const newInfo: ResultsInfo.ClassInterfaceInfo = new ResultsInfo.ClassInterfaceInfo(
286        apiInfo.getApiType(),
287        new Comment.JsDocInfo()
288      );
289      newInfo.setName(apiInfo.getApiName());
290      newInfo.setParentClasses(classInfo.getParentClasses());
291      infos.push(newInfo);
292    }
293    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
294      const newInfo: ResultsInfo.ClassInterfaceInfo = new ResultsInfo.ClassInterfaceInfo(
295        apiInfo.getApiType(),
296        jsDocInfo
297      );
298      newInfo.setName(apiInfo.getApiName());
299      newInfo.setParentClasses(classInfo.getParentClasses());
300      infos.push(newInfo);
301    });
302    return infos;
303  }
304
305  static processInterface(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
306    const infos: ResultsInfo.ClassInterfaceInfo[] = [];
307    const interfaceInfo: InterfaceInfo = apiInfo as InterfaceInfo;
308    const jsDocInfos: Comment.JsDocInfo[] = interfaceInfo.getJsDocInfos();
309    if (jsDocInfos.length === 0) {
310      const newInfo: ResultsInfo.ClassInterfaceInfo = new ResultsInfo.ClassInterfaceInfo(
311        apiInfo.getApiType(),
312        new Comment.JsDocInfo()
313      );
314      newInfo.setName(apiInfo.getApiName());
315      newInfo.setParentClasses(interfaceInfo.getParentClasses());
316      infos.push(newInfo);
317    }
318    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
319      const newInfo: ResultsInfo.ClassInterfaceInfo = new ResultsInfo.ClassInterfaceInfo(
320        apiInfo.getApiType(),
321        jsDocInfo
322      );
323      newInfo.setName(apiInfo.getApiName());
324      newInfo.setParentClasses(interfaceInfo.getParentClasses());
325      infos.push(newInfo);
326    });
327    return infos;
328  }
329
330  static processNamespace(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
331    const infos: ResultsInfo.NamespaceEnumInfo[] = [];
332    const interfaceInfo: NamespaceInfo = apiInfo as NamespaceInfo;
333    const jsDocInfos: Comment.JsDocInfo[] = interfaceInfo.getJsDocInfos();
334    if (jsDocInfos.length === 0) {
335      const newInfo: ResultsInfo.NamespaceEnumInfo = new ResultsInfo.NamespaceEnumInfo(
336        apiInfo.getApiType(),
337        new Comment.JsDocInfo()
338      );
339      newInfo.setName(apiInfo.getApiName());
340      infos.push(newInfo);
341    }
342    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
343      const newInfo: ResultsInfo.NamespaceEnumInfo = new ResultsInfo.NamespaceEnumInfo(apiInfo.getApiType(), jsDocInfo);
344      newInfo.setName(apiInfo.getApiName());
345      infos.push(newInfo);
346    });
347    return infos;
348  }
349
350  static processMethod(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
351    const infos: ResultsInfo.MethodInfo[] = [];
352    const methodInfo: MethodInfo = apiInfo as MethodInfo;
353    const jsDocInfos: Comment.JsDocInfo[] = methodInfo.getJsDocInfos();
354    if (jsDocInfos.length === 0) {
355      const newInfo: ResultsInfo.MethodInfo = new ResultsInfo.MethodInfo(apiInfo.getApiType(), new Comment.JsDocInfo());
356      newInfo.setName(apiInfo.getApiName());
357      newInfo.setCallForm(methodInfo.getCallForm());
358      newInfo.setReturnValue(methodInfo.getReturnValue().join(' | '));
359      methodInfo.getParams().forEach((param: ParamInfo) => {
360        const newParam: ResultsInfo.ParamInfo = new ResultsInfo.ParamInfo(param.getApiType(), new Comment.JsDocInfo());
361        newParam.setName(param.getApiName());
362        newParam.setType(param.getType().join(' | '));
363        newParam.setIsRequired(param.getIsRequired());
364        newInfo.addParam(newParam);
365      });
366      newInfo.setIsStatic(methodInfo.getIsStatic());
367      infos.push(newInfo);
368    }
369    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
370      const newInfo: ResultsInfo.MethodInfo = new ResultsInfo.MethodInfo(apiInfo.getApiType(), jsDocInfo);
371      newInfo.setName(apiInfo.getApiName());
372      newInfo.setCallForm(methodInfo.getCallForm());
373      newInfo.setReturnValue(methodInfo.getReturnValue().join(' | '));
374      methodInfo.getParams().forEach((param: ParamInfo) => {
375        const newParam: ResultsInfo.ParamInfo = new ResultsInfo.ParamInfo(param.getApiType(), new Comment.JsDocInfo());
376        newParam.setName(param.getApiName());
377        newParam.setType(param.getType().join(' | '));
378        newParam.setIsRequired(param.getIsRequired());
379        newInfo.addParam(newParam);
380      });
381      newInfo.setIsStatic(methodInfo.getIsStatic());
382      infos.push(newInfo);
383    });
384    return infos;
385  }
386
387  static processExportDefault(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
388    const infos: ResultsInfo.ExportDefaultInfo[] = [];
389    const newInfo: ResultsInfo.ExportDefaultInfo = new ResultsInfo.ExportDefaultInfo(apiInfo.getApiType());
390    newInfo.setName(apiInfo.getApiName());
391    infos.push(newInfo);
392    return infos;
393  }
394
395  static processImportInfo(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
396    const infos: ResultsInfo.ImportInfo[] = [];
397    const importInfo: ImportInfo = apiInfo as ImportInfo;
398    const newInfo: ResultsInfo.ImportInfo = new ResultsInfo.ImportInfo(apiInfo.getApiType());
399    importInfo.getImportValues().forEach((importValue: ExportImportValue) => {
400      newInfo.addImportValue(importValue.key, importValue.value);
401    });
402    infos.push(newInfo);
403    return infos;
404  }
405
406  static processConstant(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
407    const infos: ResultsInfo.ConstantInfo[] = [];
408    const constantInfo: ConstantInfo = apiInfo as ConstantInfo;
409    const jsDocInfos: Comment.JsDocInfo[] = constantInfo.getJsDocInfos();
410    if (jsDocInfos.length === 0) {
411      const newInfo: ResultsInfo.ConstantInfo = new ResultsInfo.ConstantInfo(
412        apiInfo.getApiType(),
413        new Comment.JsDocInfo()
414      );
415      newInfo.setName(apiInfo.getApiName());
416      const value: string = constantInfo.getValue();
417      newInfo.setValue(value.replace(ResultsProcessHelper.regQuotation, '$1'));
418      newInfo.setType(isNaN(Number(value)) ? 'string' : 'number');
419      const declarationNode: ts.VariableDeclaration = constantInfo.getNode() as ts.VariableDeclaration;
420      if (declarationNode.initializer) {
421        const typeOfLiteral: string | undefined = typeMap.get(declarationNode.initializer.kind);
422        newInfo.setType(typeOfLiteral ? typeOfLiteral : '');
423      }
424      infos.push(newInfo);
425    }
426    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
427      const newInfo: ResultsInfo.ConstantInfo = new ResultsInfo.ConstantInfo(apiInfo.getApiType(), jsDocInfo);
428      newInfo.setName(apiInfo.getApiName());
429      const value: string = constantInfo.getValue();
430      newInfo.setValue(value.replace(ResultsProcessHelper.regQuotation, '$1'));
431      newInfo.setType(isNaN(Number(value)) ? 'string' : 'number');
432      const declarationNode: ts.VariableDeclaration = constantInfo.getNode() as ts.VariableDeclaration;
433      if (declarationNode.initializer) {
434        const typeOfLiteral: string | undefined = typeMap.get(declarationNode.initializer.kind);
435        newInfo.setType(typeOfLiteral ? typeOfLiteral : '');
436      }
437      infos.push(newInfo);
438    });
439    return infos;
440  }
441
442  static processDeclareConstant(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
443    const infos: ResultsInfo.DeclareConstInfo[] = [];
444    const constantInfo: ConstantInfo = apiInfo as ConstantInfo;
445    const jsDocInfos: Comment.JsDocInfo[] = constantInfo.getJsDocInfos();
446    if (jsDocInfos.length === 0) {
447      const newInfo: ResultsInfo.DeclareConstInfo = new ResultsInfo.DeclareConstInfo(
448        apiInfo.getApiType(),
449        new Comment.JsDocInfo()
450      );
451      newInfo.setName(apiInfo.getApiName());
452      newInfo.setType(constantInfo.getValue());
453      const declarationNode: ts.VariableDeclaration = constantInfo.getNode() as ts.VariableDeclaration;
454      if (declarationNode.initializer) {
455        const typeOfLiteral: string | undefined = typeMap.get(declarationNode.initializer.kind);
456        newInfo.setType(typeOfLiteral ? typeOfLiteral : '');
457      }
458      infos.push(newInfo);
459    }
460    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
461      const newInfo: ResultsInfo.DeclareConstInfo = new ResultsInfo.DeclareConstInfo(apiInfo.getApiType(), jsDocInfo);
462      newInfo.setName(apiInfo.getApiName());
463      newInfo.setType(constantInfo.getValue());
464      const declarationNode: ts.VariableDeclaration = constantInfo.getNode() as ts.VariableDeclaration;
465      if (declarationNode.initializer) {
466        const typeOfLiteral: string | undefined = typeMap.get(declarationNode.initializer.kind);
467        newInfo.setType(typeOfLiteral ? typeOfLiteral : '');
468      }
469      infos.push(newInfo);
470    });
471    return infos;
472  }
473
474  static processEnum(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
475    const infos: ResultsInfo.NamespaceEnumInfo[] = [];
476    const enumInfo: EnumInfo = apiInfo as EnumInfo;
477    const jsDocInfos: Comment.JsDocInfo[] = enumInfo.getJsDocInfos();
478    if (jsDocInfos.length === 0) {
479      const newInfo: ResultsInfo.NamespaceEnumInfo = new ResultsInfo.NamespaceEnumInfo(
480        apiInfo.getApiType(),
481        new Comment.JsDocInfo()
482      );
483      newInfo.setName(apiInfo.getApiName());
484      infos.push(newInfo);
485    }
486    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
487      const newInfo: ResultsInfo.NamespaceEnumInfo = new ResultsInfo.NamespaceEnumInfo(apiInfo.getApiType(), jsDocInfo);
488      newInfo.setName(apiInfo.getApiName());
489      infos.push(newInfo);
490    });
491    return infos;
492  }
493
494  static processEnumMember(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
495    const infos: ResultsInfo.EnumValueInfo[] = [];
496    const enumValueInfo: EnumValueInfo = apiInfo as EnumValueInfo;
497    const jsDocInfos: Comment.JsDocInfo[] = enumValueInfo.getJsDocInfos();
498    if (jsDocInfos.length === 0) {
499      const newInfo: ResultsInfo.EnumValueInfo = new ResultsInfo.EnumValueInfo(
500        apiInfo.getApiType(),
501        new Comment.JsDocInfo()
502      );
503      newInfo.setName(apiInfo.getApiName());
504      newInfo.setValue(enumValueInfo.getValue());
505      infos.push(newInfo);
506    }
507    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
508      const newInfo: ResultsInfo.EnumValueInfo = new ResultsInfo.EnumValueInfo(apiInfo.getApiType(), jsDocInfo);
509      newInfo.setName(apiInfo.getApiName());
510      newInfo.setValue(enumValueInfo.getValue());
511      infos.push(newInfo);
512    });
513    return infos;
514  }
515
516  static processTypeAlias(apiInfo: BasicApiInfo): ResultsInfo.BasicApiInfo[] {
517    const infos: ResultsInfo.BasicApiInfo[] = [];
518    const typeAliasInfo: TypeAliasInfo = apiInfo as TypeAliasInfo;
519    const jsDocInfos: Comment.JsDocInfo[] = typeAliasInfo.getJsDocInfos();
520    if (jsDocInfos.length === 0) {
521      const newInfo: ResultsInfo.BasicApiInfo = ResultsProcessHelper.processTypeAliasGetNewInfo(
522        typeAliasInfo,
523        new Comment.JsDocInfo()
524      );
525      infos.push(newInfo);
526    }
527    jsDocInfos.forEach((jsDocInfo: Comment.JsDocInfo) => {
528      const newInfo: ResultsInfo.BasicApiInfo = ResultsProcessHelper.processTypeAliasGetNewInfo(
529        typeAliasInfo,
530        jsDocInfo
531      );
532      infos.push(newInfo);
533    });
534    return infos;
535  }
536  static processTypeAliasGetNewInfo(
537    typeAliasInfo: TypeAliasInfo,
538    jsDocInfo: Comment.JsDocInfo
539  ): ResultsInfo.BasicApiInfo {
540    if (typeAliasInfo.getTypeName() === TypeAliasType.UNION_TYPE) {
541      const newInfo: ResultsInfo.UnionTypeInfo = new ResultsInfo.UnionTypeInfo(typeAliasInfo.getTypeName(), jsDocInfo);
542      newInfo.setName(typeAliasInfo.getApiName());
543      newInfo.addValueRanges(
544        typeAliasInfo.getType().map((type: string) => {
545          return type.replace(ResultsProcessHelper.regQuotation, '$1');
546        })
547      );
548      return newInfo;
549    }
550    const newInfo: ResultsInfo.TypeAliasInfo = new ResultsInfo.TypeAliasInfo(typeAliasInfo.getApiType(), jsDocInfo);
551    newInfo.setName(typeAliasInfo.getApiName());
552    newInfo.setType(typeAliasInfo.getType().join(' | '));
553    return newInfo;
554  }
555}
556
557const typeMap: Map<ts.SyntaxKind, string> = new Map([
558  [ts.SyntaxKind.StringLiteral, 'string'],
559  [ts.SyntaxKind.NumericLiteral, 'number'],
560]);
561
562/**
563 * api节点类型对应的处理方法，获取diff信息
564 */
565export const resultsProcessMethod: Map<string, ResultsInfo.NodeProcessorInterface> = new Map([
566  [ApiType.PROPERTY, ResultsProcessHelper.processProperty],
567  [ApiType.CLASS, ResultsProcessHelper.processClass],
568  [ApiType.INTERFACE, ResultsProcessHelper.processInterface],
569  [ApiType.NAMESPACE, ResultsProcessHelper.processNamespace],
570  [ApiType.METHOD, ResultsProcessHelper.processMethod],
571  // [ApiType.PARAM, ResultsProcessHelper.processParam],
572  // [ApiType.MODULE, ResultsProcessHelper.processModule],
573  // [ApiType.EXPORT, ResultsProcessHelper.processExport],
574  [ApiType.EXPORT_DEFAULT, ResultsProcessHelper.processExportDefault],
575  [ApiType.IMPORT, ResultsProcessHelper.processImportInfo],
576  [ApiType.CONSTANT, ResultsProcessHelper.processConstant],
577  [ApiType.DECLARE_CONST, ResultsProcessHelper.processDeclareConstant],
578  [ApiType.ENUM, ResultsProcessHelper.processEnum],
579  [ApiType.ENUM_VALUE, ResultsProcessHelper.processEnumMember],
580  [ApiType.TYPE_ALIAS, ResultsProcessHelper.processTypeAlias],
581]);
582