xref: /ide/tools/previewer/automock/mock-generate/src/declaration-node/moduleDeclaration.ts

/*
 * Copyright (c) 2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {
  isClassDeclaration,
  isEnumDeclaration,
  isExportDeclaration,
  isFunctionDeclaration,
  isIdentifier,
  isImportEqualsDeclaration,
  isInterfaceDeclaration,
  isModuleBlock,
  isModuleDeclaration,
  isTypeAliasDeclaration,
  isVariableStatement
} from 'typescript';
import type { ModuleDeclaration, Node, SourceFile, ModuleBody } from 'typescript';
import { getExportKeyword } from '../common/commonUtils';
import { getClassDeclaration } from './classDeclaration';
import type { ClassEntity } from './classDeclaration';
import { getEnumDeclaration } from './enumDeclaration';
import type { EnumEntity } from './enumDeclaration';
import { getFunctionDeclaration } from './functionDeclaration';
import type { FunctionEntity } from './functionDeclaration';
import { getExportDeclaration, getModuleImportEqual } from './importAndExportDeclaration';
import type { ImportEuqalEntity } from './importAndExportDeclaration';
import { getInterfaceDeclaration } from './interfaceDeclaration';
import type { InterfaceEntity } from './interfaceDeclaration';
import { getTypeAliasDeclaration } from './typeAliasDeclaration';
import type { TypeAliasEntity } from './typeAliasDeclaration';
import { getVariableStatementDeclaration } from './variableStatementResolve';
import type { StatementEntity } from './variableStatementResolve';

interface SubstepGetModuleparam {
  typeAliasDeclarations: Array<TypeAliasEntity>;
  classDeclarations: Array<ClassEntity>;
  interfaceDeclarations: Array<InterfaceEntity>;
  functionDeclarations: Map<string, Array<FunctionEntity>>;
  enumDeclarations: Array<EnumEntity>;
  moduleDeclarations: Array<ModuleBlockEntity>;
  variableStatements: Array<Array<StatementEntity>>;
  moduleImportEquaqls: Array<ImportEuqalEntity>;
  exportDeclarations: Array<string>;
  sourceFile: SourceFile;
  fileName: string;
  moduleBody: ModuleBody;
}

export interface ModuleBlockEntity {
  moduleName: string;
  exportModifiers: Array<number>;
  typeAliasDeclarations: Array<TypeAliasEntity>;
  classDeclarations: Array<ClassEntity>;
  interfaceDeclarations: Array<InterfaceEntity>;
  functionDeclarations: Map<string, Array<FunctionEntity>>;
  enumDeclarations: Array<EnumEntity>;
  moduleDeclarations: Array<ModuleBlockEntity>;
  variableStatements: Array<Array<StatementEntity>>;
  moduleImportEquaqls: Array<ImportEuqalEntity>;
  exportDeclarations: Array<string>;
}

/**
 * get module info
 * @param node
 * @param sourceFile
 * @param fileName
 * @returns
 */
export function getModuleDeclaration(node: Node, sourceFile: SourceFile, fileName: string): ModuleBlockEntity {
  const moduleNode = node as ModuleDeclaration;
  const typeAliasDeclarations: Array<TypeAliasEntity> = [];
  const classDeclarations: Array<ClassEntity> = [];
  const interfaceDeclarations: Array<InterfaceEntity> = [];
  const functionDeclarations: Map<string, Array<FunctionEntity>> = new Map<string, Array<FunctionEntity>>();
  const enumDeclarations: Array<EnumEntity> = [];
  const moduleDeclarations: Array<ModuleBlockEntity> = [];
  const variableStatements: Array<Array<StatementEntity>> = [];
  const moduleImportEquaqls: Array<ImportEuqalEntity> = [];
  const exportDeclarations: Array<string> = [];
  const moduleBody = moduleNode.body;
  let moduleName = '';
  if (isIdentifier(moduleNode.name)) {
    moduleName = moduleNode.name.escapedText.toString();
  } else {
    moduleName = sourceFile.text.substring(moduleNode.name.pos, moduleNode.name.end).trim();
  }

  let exportModifiers: Array<number> = [];
  const modifiers = moduleNode.modifiers;
  if (modifiers !== undefined) {
    exportModifiers = getExportKeyword(modifiers);
  }
  const SubstepModuleBlockEntitys: SubstepGetModuleparam = substepModule({
    typeAliasDeclarations,
    classDeclarations,
    interfaceDeclarations,
    functionDeclarations,
    enumDeclarations,
    moduleDeclarations,
    variableStatements,
    moduleImportEquaqls,
    exportDeclarations,
    moduleBody,
    sourceFile,
    fileName
  });
  delete SubstepModuleBlockEntitys.moduleBody;
  delete SubstepModuleBlockEntitys.sourceFile;
  delete SubstepModuleBlockEntitys.fileName;
  return {
    ...SubstepModuleBlockEntitys,
    exportModifiers,
    moduleName
  };
}

/**
 * get some module info
 * @param SubstepGetModuleparam
 * @returns
 */
function substepModule(props: SubstepGetModuleparam): SubstepGetModuleparam {
  if (props.moduleBody !== undefined && isModuleBlock(props.moduleBody)) {
    props.moduleBody.statements.forEach(value => {
      if (isFunctionDeclaration(value)) {
        const functionEntity = getFunctionDeclaration(value, props.sourceFile);
        if (props.functionDeclarations.get(functionEntity.functionName) !== undefined) {
          props.functionDeclarations.get(functionEntity.functionName)?.push(functionEntity);
        } else {
          const functionArray: Array<FunctionEntity> = [];
          functionArray.push(functionEntity);
          props.functionDeclarations.set(functionEntity.functionName, functionArray);
        }
      } else if (isTypeAliasDeclaration(value)) {
        props.typeAliasDeclarations.push(getTypeAliasDeclaration(value, props.sourceFile));
      } else if (isEnumDeclaration(value)) {
        props.enumDeclarations.push(getEnumDeclaration(value, props.sourceFile));
      } else if (isClassDeclaration(value)) {
        props.classDeclarations.push(getClassDeclaration(value, props.sourceFile));
      } else if (isInterfaceDeclaration(value)) {
        props.interfaceDeclarations.push(getInterfaceDeclaration(value, props.sourceFile));
      } else if (isModuleDeclaration(value)) {
        props.moduleDeclarations.push(getModuleDeclaration(value, props.sourceFile, props.fileName));
      } else if (isVariableStatement(value)) {
        props.variableStatements.push(getVariableStatementDeclaration(value, props.sourceFile));
      } else if (isImportEqualsDeclaration(value)) {
        props.moduleImportEquaqls.push(getModuleImportEqual(value, props.sourceFile));
      } else if (isExportDeclaration(value)) {
        props.exportDeclarations.push(getExportDeclaration(value, props.sourceFile));
      } else {
        console.log('--------------------------- uncaught module type start -----------------------');
        console.log('fileName: ' + props.fileName);
        console.log(value);
        console.log('--------------------------- uncaught module type end -----------------------');
      }
    });
  }
  return props;
}