diff --git a/compiler/src/process_kit_import.ts b/compiler/src/process_kit_import.ts
index 2883a99f6fc0ff7582c6f5cca28c2c7f7d18dad7..d07fd5824c46863d2eae336115e5983ead2baa8a 100644
--- a/compiler/src/process_kit_import.ts
+++ b/compiler/src/process_kit_import.ts
@@ -22,7 +22,6 @@ import {
   LogType
 } from './utils';
 import { projectConfig } from '../main';
-import { ESMODULE } from './pre_define';
 import { ModuleSourceFile } from './fast_build/ark_compiler/module/module_source_file';
 import { collectKitModules } from './fast_build/system_api/rollup-plugin-system-api';
 
@@ -79,20 +78,19 @@ export function processKitImport(): Function {
     return (node: ts.SourceFile) => {
       compilingEtsOrTsFiles.push(path.normalize(node.fileName));
 
-      KitInfo.init(node);
+      KitInfo.init(node, context);
 
-      if (projectConfig.compileMode === ESMODULE && projectConfig.processTs === true) {
+      if (projectConfig.processTs === true) {
         if (ts.hasTsNoCheckOrTsIgnoreFlag(node)) {
           hasTsNoCheckOrTsIgnoreFiles.push(path.normalize(node.fileName));
           // process KitImport transforming
           return ts.visitEachChild(node, visitor, context); // this node used for [writeFile]
-        } else {
-          // process [ConstEnum] + [TypeExportImport] + [KitImport] transforming
-          const processedNode: ts.SourceFile =
-            ts.visitEachChild(ts.getTypeExportImportAndConstEnumTransformer(context)(node), visitor, context);
-          ModuleSourceFile.newSourceFile(path.normalize(processedNode.fileName), processedNode);
-          return node; // this node not used for [writeFile]
         }
+        // process [ConstEnum] + [TypeExportImport] + [KitImport] transforming
+        const processedNode: ts.SourceFile =
+          ts.visitEachChild(ts.getTypeExportImportAndConstEnumTransformer(context)(node), visitor, context);
+        ModuleSourceFile.newSourceFile(path.normalize(processedNode.fileName), processedNode);
+        return node; // this node not used for [writeFile]
       }
       // process KitImport transforming
       return ts.visitEachChild(node, visitor, context);
@@ -185,6 +183,8 @@ class KitInfo {
   private static currentFileType: FileType = FileType.ETS;
   private static currentKitName: string = '';
   private static currentSourcefile: string = '';
+  private static needSkipType: boolean = true;
+  private static tsEmitResolver: any;
 
   private symbols: KitSymbols;
   private kitNode: TSModuleDeclaration;
@@ -200,7 +200,9 @@ class KitInfo {
     this.kitNodeModifier = ts.canHaveDecorators(this.kitNode) ? ts.getModifiers(this.kitNode) : undefined;
   }
 
-  static init(node: ts.SourceFile): void {
+  static init(node: ts.SourceFile, context: ts.TransformationContext): void {
+    // @ts-ignore
+    this.tsEmitResolver = context.getEmitResolver();
     this.currentSourcefile = node.fileName;
     if (/\.ts$/.test(node.fileName)) {
       this.setFileType(FileType.TS);
@@ -208,6 +210,10 @@ class KitInfo {
       this.setFileType(FileType.ETS);
     }
 
+    if (projectConfig.processTs === true && !ts.hasTsNoCheckOrTsIgnoreFlag(node)) {
+      this.needSkipType = false;
+    }
+
     kitTransformLog.sourceFile = node;
   }
 
@@ -231,6 +237,49 @@ class KitInfo {
     return this.currentSourcefile;
   }
 
+  static needSkipTypeSymbolOfNode(node: ts.Node): boolean {
+    if (!this.needSkipType) {
+      return false;
+    }
+
+    // need to skip type symbol
+    const resolver = this.tsEmitResolver;
+    let isTypeSymbol: boolean = false;
+    switch(node.kind) {
+      case ts.SyntaxKind.ImportDeclaration:
+      case ts.SyntaxKind.ImportClause: {
+        const importClause = ts.isImportClause(node) ? node : (node as ts.ImportDeclaration).importClause;
+        if (importClause) {
+          isTypeSymbol = importClause.isTypeOnly;
+          if (importClause.name &&
+            !resolver.isReferencedAliasDeclaration(importClause) && resolver.isReferenced(node)) {
+              isTypeSymbol = true;
+          }
+        }
+        break;
+      }
+      case ts.SyntaxKind.ImportSpecifier: {
+        isTypeSymbol = (node as ts.ImportSpecifier).isTypeOnly;
+        if (!resolver.isReferencedAliasDeclaration(node) && resolver.isReferenced(node)) {
+          isTypeSymbol = true;
+        }
+        break;
+      }
+      case ts.SyntaxKind.ExportDeclaration: {
+        isTypeSymbol = (node as ts.ExportDeclaration).isTypeOnly;
+        break;
+      }
+      case ts.SyntaxKind.ExportSpecifier: {
+        isTypeSymbol = (node as ts.ExportSpecifier).isTypeOnly;
+        if (!resolver.isValueAliasDeclaration(node)) {
+          isTypeSymbol = true;
+        }
+        break;
+      }
+    }
+    return isTypeSymbol;
+  }
+
   static processImportDecl(kitNode: ts.ImportDeclaration, symbols: Record<string, KitSymbol>) {
     if (kitNode.importClause!.namedBindings) {
       const namedBindings: ts.NamedImportBindings = kitNode.importClause.namedBindings;
@@ -245,7 +294,7 @@ class KitInfo {
       }
     }
 
-    if (kitNode.importClause!.name) {
+    if (kitNode.importClause!.name && !this.needSkipTypeSymbolOfNode(kitNode.importClause)) {
       // e.g. import default from "@kit.xxx"
       const defaultName: string = kitNode.importClause.name.text;
       if (!this.currentKitInfo) {
@@ -331,6 +380,11 @@ class KitInfo {
   }
 
   collectSpecifier(element: TSspecifier) {
+    if (KitInfo.needSkipTypeSymbolOfNode(this.getKitNode()) || KitInfo.needSkipTypeSymbolOfNode(element)) {
+      // skip type symbol
+      return;
+    }
+
     const localName: string = element.name.text;
     const importName: string = element.propertyName ? element.propertyName.text : localName;
     this.newSpecificerInfo(localName, importName, element);