xref: /ide/tools/previewer/automock/mock-generate/src/declaration-node/importAndExportDeclaration.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 type {
  ExportAssignment,
  ExportDeclaration,
  ImportDeclaration,
  ImportEqualsDeclaration,
  Node,
  SourceFile
} from 'typescript';
import { isImportDeclaration } from 'typescript';

/**
 * get current sourceFile all imports
 * @param sourceFile
 * @returns
 */
export function getImportDeclarationArray(sourceFile: SourceFile): Array<ImportElementEntity> {
  const importDeclarations: Array<ImportElementEntity> = [];
  sourceFile.forEachChild(node => {
    if (isImportDeclaration(node)) {
      importDeclarations.push(getImportDeclaration(node, sourceFile));
    }
  });
  return importDeclarations;
}

/**
 * get module inner import info
 * @param importEqualNode
 * @param sourceFile
 * @returns
 */
export function getModuleImportEqual(
  importEqualNode: ImportEqualsDeclaration,
  sourceFile: SourceFile
): ImportEuqalEntity {
  const fileText = sourceFile.getFullText();
  const textRange = importEqualNode.moduleReference;
  return {
    importEqualName: importEqualNode.name.escapedText.toString(),
    importEqualTypeName: fileText.slice(textRange.pos, textRange.end).trim(),
    importEqualTypeKind: importEqualNode.moduleReference.kind
  };
}

/**
 * get export info
 * @param exportNode
 * @param sourceFile
 * @returns
 */
export function getExportDeclaration(exportNode: ExportDeclaration, sourceFile: SourceFile): string {
  return sourceFile.text.substring(exportNode.pos, exportNode.end).trim();
}

/**
 * get import info
 * @param node
 * @param sourceFile
 * @returns
 */
export function getImportDeclaration(node: Node, sourceFile: SourceFile): ImportElementEntity {
  let importElements = '';
  const importNode = node as ImportDeclaration;
  const fileText = sourceFile.getFullText();
  const moduleSpecifier = importNode.moduleSpecifier;
  const importPath = fileText.substring(moduleSpecifier.pos, moduleSpecifier.end).trim();
  const importClause = importNode.importClause;
  if (importClause !== undefined) {
    importElements = fileText.substring(importClause.pos, importClause.end).trim();
    if (importElements.startsWith('type ')) {
      importElements = importElements.replace('type ', '');
    }
  }

  return {
    importPath: importPath,
    importElements: importElements
  };
}

/**
 * get export info
 * @param exportAssigment
 * @param sourceFile
 * @returns
 */
export function getExportAssignment(exportAssigment: ExportAssignment, sourceFile: SourceFile): Array<string> {
  const exportAssignments: Array<string> = [];
  if (exportAssigment.expression !== undefined) {
    exportAssignments.push(
      sourceFile.text.substring(exportAssigment.expression.pos, exportAssigment.expression.end).trim()
    );
  }
  return exportAssignments;
}

export interface ImportElementEntity {
  importPath: string;
  importElements: string;
}

export interface ExportElementEntity {
  exportName: string;
}

export interface ImportEuqalEntity {
  importEqualName: string;
  importEqualTypeName: string;
  importEqualTypeKind: number;
}