fix pr issue

Signed-off-by: zhangrengao <zhangrengao1@huawei.com> Change-Id: I0815b0f0c28aeeebfad97b4fc6ced1e607163512
2026-07-18 16:04:32 -04:00 · 2022-06-06 10:43:41 +08:00
parent 6a69114ba5
commit 8d83033839
9 changed files with 191 additions and 176 deletions
@@ -345,7 +345,7 @@ function loadModuleInfo(projectConfig, envArgs) {
    projectConfig.modulePathMap = buildJsonInfo.modulePathMap;
    projectConfig.processTs = false;
    projectConfig.buildArkMode = envArgs.buildMode;
-    if (buildJsonInfo.compileMode === 'esmodle') {
+    if (buildJsonInfo.compileMode === 'esmodule') {
      projectConfig.nodeModulesPath = buildJsonInfo.nodeModulesPath;
    }
  }
@@ -23,10 +23,10 @@ const red: string = '\u001b[31m';
 const reset: string = '\u001b[39m';

 function js2abcByWorkers(jsonInput: string, cmd: string): Promise<void> {
-  const inputPaths = JSON.parse(jsonInput);
+  const inputPaths: any = JSON.parse(jsonInput);
  for (let i = 0; i < inputPaths.length; ++i) {
-    const input = inputPaths[i].path;
-    const singleCmd = `${cmd} "${input}"`;
+    const input: string = inputPaths[i].path;
+    const singleCmd: any = `${cmd} "${input}"`;
    logger.debug('gen abc cmd is: ', singleCmd, ' ,file size is:', inputPaths[i].size, ' byte');
    try {
      childProcess.execSync(singleCmd);
@@ -27,7 +27,8 @@ import {
  genAbcFileName,
  mkdirsSync,
  genSourceMapFileName,
-  checkNodeModulesFile} from './utils';
+  checkNodeModulesFile
+} from './utils';
 import { projectConfig } from '../main';
 import {
  ESMODULE,
@@ -44,8 +45,8 @@ import {
 } from './pre_define';

 const firstFileEXT: string = '_.js';
-const genAbcScript = 'gen_abc.js';
-const genModuleAbcScript = 'gen_module_abc.js';
+const genAbcScript: string = 'gen_abc.js';
+const genModuleAbcScript: string = 'gen_module_abc.js';
 let output: string;
 let isWin: boolean = false;
 let isMac: boolean = false;
@@ -63,15 +64,15 @@ const moduleInfos: Array<ModuleInfo> = [];
 let filterModuleInfos: Array<ModuleInfo> = [];
 const commonJsModuleInfos: Array<ModuleInfo> = [];
 const ESMModuleInfos: Array<ModuleInfo> = [];
-const entryInfos = new Map<string, EntryInfo>();
+const entryInfos: Map<string, EntryInfo> = new Map<string, EntryInfo>();
 let hashJsonObject = {};
 let moduleHashJsonObject = {};
-let buildPathInfo = '';
+let buildPathInfo: string = '';

 const red: string = '\u001b[31m';
 const reset: string = '\u001b[39m';
-const hashFile = 'gen_hash.json';
-const ARK = '/ark/';
+const hashFile: string = 'gen_hash.json';
+const ARK: string = '/ark/';

 class ModuleInfo {
  filePath: string;
@@ -173,46 +174,46 @@ function getEntryInfo(tempFilePath: string, resourceResolveData: any) {
  if (!resourceResolveData.descriptionFilePath) {
    return;
  }
-  const packageName = resourceResolveData.descriptionFileData['name'];
-  const packageJsonPath = resourceResolveData.descriptionFilePath;
-  let npmInfoPath = path.resolve(packageJsonPath, '..');
-  const fakeEntryPath = path.resolve(npmInfoPath, 'fake.js');
-  const tempFakeEntryPath = genTemporaryPath(fakeEntryPath, projectConfig.projectPath, process.env.cachePath);
-  const buildFakeEntryPath = genBuildPath(fakeEntryPath, projectConfig.projectPath, projectConfig.buildPath);
+  const packageName: string = resourceResolveData.descriptionFileData['name'];
+  const packageJsonPath: string = resourceResolveData.descriptionFilePath;
+  let npmInfoPath: string = path.resolve(packageJsonPath, '..');
+  const fakeEntryPath: string = path.resolve(npmInfoPath, 'fake.js');
+  const tempFakeEntryPath: string = genTemporaryPath(fakeEntryPath, projectConfig.projectPath, process.env.cachePath);
+  const buildFakeEntryPath: string = genBuildPath(fakeEntryPath, projectConfig.projectPath, projectConfig.buildPath);
  npmInfoPath = toUnixPath(path.resolve(tempFakeEntryPath, '..'));
-  const buildNpmInfoPath = toUnixPath(path.resolve(buildFakeEntryPath, '..'));
+  const buildNpmInfoPath: string = toUnixPath(path.resolve(buildFakeEntryPath, '..'));
  if (entryInfos.has(npmInfoPath)) {
    return;
  }

-  let abcFileName = genAbcFileName(tempFilePath);
-  const abcFilePaths = abcFileName.split(NODE_MODULES);
+  let abcFileName: string = genAbcFileName(tempFilePath);
+  const abcFilePaths: string[] = abcFileName.split(NODE_MODULES);
  abcFileName = [NODE_MODULES, abcFilePaths[abcFilePaths.length - 1]].join(path.sep);
  abcFileName = toUnixPath(abcFileName);

-  const packagePaths = tempFilePath.split(NODE_MODULES);
-  const entryPaths = packagePaths[packagePaths.length - 1].split(packageName);
-  let entry = toUnixPath(entryPaths[entryPaths.length - 1]);
+  const packagePaths: string[] = tempFilePath.split(NODE_MODULES);
+  const entryPaths: string[] = packagePaths[packagePaths.length - 1].split(packageName);
+  let entry: string = toUnixPath(entryPaths[entryPaths.length - 1]);
  if (entry.startsWith('/')) {
    entry = entry.slice(1, entry.length);
  }
-  const entryInfo = new EntryInfo(npmInfoPath, abcFileName, buildNpmInfoPath, entry);
+  const entryInfo: EntryInfo = new EntryInfo(npmInfoPath, abcFileName, buildNpmInfoPath, entry);
  entryInfos.set(npmInfoPath, entryInfo);
 }

 function processNodeModulesFile(filePath: string, tempFilePath: string, buildFilePath: string, abcFilePath: string, nodeModulesFile: Array<string>, module: any) {
  getEntryInfo(tempFilePath, module.resourceResolveData);
-  const descriptionFileData = module.resourceResolveData.descriptionFileData;
+  const descriptionFileData: any = module.resourceResolveData.descriptionFileData;
  if (descriptionFileData && descriptionFileData['type'] && descriptionFileData['type'] === 'module') {
-    const tempModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
+    const tempModuleInfo: ModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
    moduleInfos.push(tempModuleInfo);
    nodeModulesFile.push(tempFilePath);
-  } else if (filePath.endsWith('mjs')) {
-    const tempModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
+  } else if (filePath.endsWith(EXTNAME_MJS)) {
+    const tempModuleInfo: ModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
    moduleInfos.push(tempModuleInfo);
    nodeModulesFile.push(tempFilePath);
  } else {
-    const tempModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, true);
+    const tempModuleInfo: ModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, true);
    moduleInfos.push(tempModuleInfo);
    nodeModulesFile.push(tempFilePath);
  }
@@ -228,11 +229,11 @@ function processEtsModule(filePath: string, tempFilePath: string, buildFilePath:
    tempFilePath = tempFilePath.replace(/\.ets$/, EXTNAME_JS);
    buildFilePath = buildFilePath.replace(/\.ets$/, EXTNAME_JS);
  }
-  const abcFilePath = genAbcFileName(tempFilePath);
+  const abcFilePath: string = genAbcFileName(tempFilePath);
  if (checkNodeModulesFile(filePath, projectConfig.projectPath)) {
    processNodeModulesFile(filePath, tempFilePath, buildFilePath, abcFilePath, nodeModulesFile, module);
  } else {
-    const tempModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
+    const tempModuleInfo: ModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
    moduleInfos.push(tempModuleInfo);
  }
 }
@@ -246,11 +247,11 @@ function processTsModule(filePath: string, tempFilePath: string, buildFilePath:
    tempFilePath = tempFilePath.replace(/\.ts$/, EXTNAME_JS);
    buildFilePath = buildFilePath.replace(/\.ts$/, EXTNAME_JS);
  }
-  const abcFilePath = genAbcFileName(tempFilePath);
+  const abcFilePath: string = genAbcFileName(tempFilePath);
  if (checkNodeModulesFile(filePath, projectConfig.projectPath)) {
    processNodeModulesFile(filePath, tempFilePath, buildFilePath, abcFilePath, nodeModulesFile, module);
  } else {
-    const tempModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
+    const tempModuleInfo: ModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
    moduleInfos.push(tempModuleInfo);
  }
 }
@@ -263,11 +264,11 @@ function processJsModule(filePath: string, tempFilePath: string, buildFilePath:
  if (filePath.endsWith(EXTNAME_MJS) || filePath.endsWith(EXTNAME_CJS)) {
    fs.copyFileSync(filePath, tempFilePath);
  }
-  const abcFilePath = genAbcFileName(tempFilePath);
+  const abcFilePath: string = genAbcFileName(tempFilePath);
  if (checkNodeModulesFile(filePath, projectConfig.projectPath)) {
    processNodeModulesFile(filePath, tempFilePath, buildFilePath, abcFilePath, nodeModulesFile, module);
  } else {
-    const tempModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
+    const tempModuleInfo: ModuleInfo = new ModuleInfo(filePath, tempFilePath, buildFilePath, abcFilePath, false);
    moduleInfos.push(tempModuleInfo);
  }
 }
@@ -281,7 +282,7 @@ function handleFinishModules(modules, callback) {
      if (tempFilePath.length === 0) {
        return;
      }
-      let buildFilePath = genBuildPath(filePath, projectConfig.projectPath, projectConfig.buildPath);
+      let buildFilePath: string = genBuildPath(filePath, projectConfig.projectPath, projectConfig.buildPath);
      tempFilePath = toUnixPath(tempFilePath);
      buildFilePath = toUnixPath(buildFilePath);
      if (filePath.endsWith(EXTNAME_ETS)) {
@@ -304,8 +305,8 @@ function handleFinishModules(modules, callback) {

 function processEntryToGenAbc(entryInfos: Map<string, EntryInfo>) {
  for (const value of entryInfos.values()) {
-    const tempAbcFilePath = toUnixPath(path.resolve(value.npmInfo, ENTRY_TXT));
-    const buildAbcFilePath = toUnixPath(path.resolve(value.buildPath, ENTRY_TXT));
+    const tempAbcFilePath: string = toUnixPath(path.resolve(value.npmInfo, ENTRY_TXT));
+    const buildAbcFilePath: string = toUnixPath(path.resolve(value.buildPath, ENTRY_TXT));
    fs.writeFileSync(tempAbcFilePath, value.entry, 'utf-8');
    if (!fs.existsSync(buildAbcFilePath)) {
      const parent: string = path.join(buildAbcFilePath, '..');
@@ -324,7 +325,7 @@ function writeFileSync(inputString: string, output: string, jsBundleFile: string
  }
  fs.writeFileSync(output, inputString);
  if (fs.existsSync(output)) {
-    const fileSize = fs.statSync(output).size;
+    const fileSize: any = fs.statSync(output).size;
    intermediateJsBundle.push({path: output, size: fileSize});
  } else {
    logger.error(red, `ETS:ERROR Failed to convert file ${jsBundleFile} to bin. ${output} is lost`, reset);
@@ -340,7 +341,7 @@ function mkDir(path_: string): void {
 }

 function getSmallestSizeGroup(groupSize: Map<number, number>) {
-  const groupSizeArray = Array.from(groupSize);
+  const groupSizeArray: any = Array.from(groupSize);
  groupSizeArray.sort(function(g1, g2) {
    return g1[1] - g2[1]; // sort by size
  });
@@ -348,7 +349,7 @@ function getSmallestSizeGroup(groupSize: Map<number, number>) {
 }

 function splitJsBundlesBySize(bundleArray: Array<File>, groupNumber: number) {
-  const result = [];
+  const result: any = [];
  if (bundleArray.length < groupNumber) {
    result.push(bundleArray);
    return result;
@@ -357,7 +358,7 @@ function splitJsBundlesBySize(bundleArray: Array<File>, groupNumber: number) {
  bundleArray.sort(function(f1: File, f2: File) {
    return f2.size - f1.size;
  });
-  const groupFileSize = new Map();
+  const groupFileSize: any = new Map();
  for (let i = 0; i < groupNumber; ++i) {
    result.push([]);
    groupFileSize.set(i, 0);
@@ -365,9 +366,9 @@ function splitJsBundlesBySize(bundleArray: Array<File>, groupNumber: number) {

  let index = 0;
  while (index < bundleArray.length) {
-    const smallestGroup = getSmallestSizeGroup(groupFileSize);
+    const smallestGroup: any = getSmallestSizeGroup(groupFileSize);
    result[smallestGroup].push(bundleArray[index]);
-    const sizeUpdate = groupFileSize.get(smallestGroup) + bundleArray[index].size;
+    const sizeUpdate: any = groupFileSize.get(smallestGroup) + bundleArray[index].size;
    groupFileSize.set(smallestGroup, sizeUpdate);
    index++;
  }
@@ -413,11 +414,11 @@ function initAbcEnv() : string[] {
 }

 function invokeCluterModuleToAbc() {
-  const abcArgs = initAbcEnv();
+  const abcArgs: string[] = initAbcEnv();

-  const clusterNewApiVersion = 16;
-  const currentNodeVersion = parseInt(process.version.split('.')[0]);
-  const useNewApi = currentNodeVersion >= clusterNewApiVersion;
+  const clusterNewApiVersion: number = 16;
+  const currentNodeVersion: number = parseInt(process.version.split('.')[0]);
+  const useNewApi: boolean = currentNodeVersion >= clusterNewApiVersion;

  if (useNewApi && cluster.isPrimary || !useNewApi && cluster.isMaster) {
    if (useNewApi) {
@@ -431,20 +432,20 @@ function invokeCluterModuleToAbc() {
    }

    if (commonJsModuleInfos.length > 0) {
-      const tempAbcArgs = abcArgs.slice(0);
+      const tempAbcArgs: string[] = abcArgs.slice(0);
      tempAbcArgs.push('-c');
-      const commonJsCmdPrefix = `${nodeJs} ${tempAbcArgs.join(' ')}`;
-      const workerData = {
+      const commonJsCmdPrefix: any = `${nodeJs} ${tempAbcArgs.join(' ')}`;
+      const workerData: any = {
        'inputs': JSON.stringify(commonJsModuleInfos),
        'cmd': commonJsCmdPrefix
      };
      cluster.fork(workerData);
    }
    if (ESMModuleInfos.length > 0) {
-      const tempAbcArgs = abcArgs.slice(0);
+      const tempAbcArgs: string[] = abcArgs.slice(0);
      tempAbcArgs.push('-m');
-      const ESMCmdPrefix = `${nodeJs} ${tempAbcArgs.join(' ')}`;
-      const workerData = {
+      const ESMCmdPrefix: any = `${nodeJs} ${tempAbcArgs.join(' ')}`;
+      const workerData: any = {
        'inputs': JSON.stringify(ESMModuleInfos),
        'cmd': ESMCmdPrefix
      };
@@ -475,14 +476,14 @@ function invokeWorkersToGenAbc() {
  }

  filterIntermediateJsBundleByHashJson(buildPathInfo, intermediateJsBundle);
-  const maxWorkerNumber = 3;
-  const splitedBundles = splitJsBundlesBySize(fileterIntermediateJsBundle, maxWorkerNumber);
-  const workerNumber = maxWorkerNumber < splitedBundles.length ? maxWorkerNumber : splitedBundles.length;
+  const maxWorkerNumber: number = 3;
+  const splitedBundles: any[] = splitJsBundlesBySize(fileterIntermediateJsBundle, maxWorkerNumber);
+  const workerNumber: number = maxWorkerNumber < splitedBundles.length ? maxWorkerNumber : splitedBundles.length;
  const cmdPrefix: string = `${nodeJs} --expose-gc "${js2abc}" ${param} `;

-  const clusterNewApiVersion = 16;
-  const currentNodeVersion = parseInt(process.version.split('.')[0]);
-  const useNewApi = currentNodeVersion >= clusterNewApiVersion;
+  const clusterNewApiVersion: number = 16;
+  const currentNodeVersion: number = parseInt(process.version.split('.')[0]);
+  const useNewApi: boolean = currentNodeVersion >= clusterNewApiVersion;

  if (useNewApi && cluster.isPrimary || !useNewApi && cluster.isMaster) {
    if (useNewApi) {
@@ -496,7 +497,7 @@ function invokeWorkersToGenAbc() {
    }

    for (let i = 0; i < workerNumber; ++i) {
-      const workerData = {
+      const workerData: any = {
        'inputs': JSON.stringify(splitedBundles[i]),
        'cmd': cmdPrefix
      };
@@ -517,27 +518,27 @@ function filterIntermediateModuleByHashJson(buildPath: string, moduleInfos: Arra
  for (let i = 0; i < moduleInfos.length; ++i) {
    filterModuleInfos.push(moduleInfos[i]);
  }
-  const hashFilePath = genHashJsonPath(buildPath);
+  const hashFilePath: string = genHashJsonPath(buildPath);
  if (hashFilePath.length === 0) {
    return;
  }
-  const updateJsonObject = {};
-  let jsonObject = {};
-  let jsonFile = '';
+  const updateJsonObject: any = {};
+  let jsonObject: any = {};
+  let jsonFile: string = '';
  if (fs.existsSync(hashFilePath)) {
    jsonFile = fs.readFileSync(hashFilePath).toString();
    jsonObject = JSON.parse(jsonFile);
    filterModuleInfos = [];
    for (let i = 0; i < moduleInfos.length; ++i) {
-      const input = moduleInfos[i].tempFilePath;
-      const abcPath = moduleInfos[i].abcFilePath;
+      const input: string = moduleInfos[i].tempFilePath;
+      const abcPath: string = moduleInfos[i].abcFilePath;
      if (!fs.existsSync(input)) {
        logger.error(red, `ETS:ERROR ${input} is lost`, reset);
        continue;
      }
      if (fs.existsSync(abcPath)) {
-        const hashInputContentData = toHashData(input);
-        const hashAbcContentData = toHashData(abcPath);
+        const hashInputContentData: any = toHashData(input);
+        const hashAbcContentData: any = toHashData(abcPath);
        if (jsonObject[input] === hashInputContentData && jsonObject[abcPath] === hashAbcContentData) {
          updateJsonObject[input] = hashInputContentData;
          updateJsonObject[abcPath] = hashAbcContentData;
@@ -561,14 +562,14 @@ function filterIntermediateModuleByHashJson(buildPath: string, moduleInfos: Arra

 function writeModuleHashJson() {
  for (let i = 0; i < filterModuleInfos.length; ++i) {
-    const input = filterModuleInfos[i].tempFilePath;
-    const abcPath = filterModuleInfos[i].abcFilePath;
+    const input: string = filterModuleInfos[i].tempFilePath;
+    const abcPath: string = filterModuleInfos[i].abcFilePath;
    if (!fs.existsSync(input) || !fs.existsSync(abcPath)) {
      logger.error(red, `ETS:ERROR ${input} is lost`, reset);
      continue;
    }
-    const hashInputContentData = toHashData(input);
-    const hashAbcContentData = toHashData(abcPath);
+    const hashInputContentData: any = toHashData(input);
+    const hashAbcContentData: any = toHashData(abcPath);
    moduleHashJsonObject[input] = hashInputContentData;
    moduleHashJsonObject[abcPath] = hashAbcContentData;
    mkdirsSync(path.dirname(filterModuleInfos[i].buildFilePath));
@@ -578,7 +579,7 @@ function writeModuleHashJson() {
      fs.copyFileSync(genSourceMapFileName(moduleInfos[i].tempFilePath), genSourceMapFileName(moduleInfos[i].buildFilePath));
    }
  }
-  const hashFilePath = genHashJsonPath(buildPathInfo);
+  const hashFilePath: string = genHashJsonPath(buildPathInfo);
  if (hashFilePath.length === 0) {
    return;
  }
@@ -589,27 +590,27 @@ function filterIntermediateJsBundleByHashJson(buildPath: string, inputPaths: Fil
  for (let i = 0; i < inputPaths.length; ++i) {
    fileterIntermediateJsBundle.push(inputPaths[i]);
  }
-  const hashFilePath = genHashJsonPath(buildPath);
+  const hashFilePath: string = genHashJsonPath(buildPath);
  if (hashFilePath.length === 0) {
    return;
  }
-  const updateJsonObject = {};
-  let jsonObject = {};
-  let jsonFile = '';
+  const updateJsonObject: any = {};
+  let jsonObject: any = {};
+  let jsonFile: string = '';
  if (fs.existsSync(hashFilePath)) {
    jsonFile = fs.readFileSync(hashFilePath).toString();
    jsonObject = JSON.parse(jsonFile);
    fileterIntermediateJsBundle = [];
    for (let i = 0; i < inputPaths.length; ++i) {
-      const input = inputPaths[i].path;
-      const abcPath = input.replace(/_.js$/, EXTNAME_ABC);
+      const input: string = inputPaths[i].path;
+      const abcPath: string = input.replace(/_.js$/, EXTNAME_ABC);
      if (!fs.existsSync(input)) {
        logger.error(red, `ETS:ERROR ${input} is lost`, reset);
        continue;
      }
      if (fs.existsSync(abcPath)) {
-        const hashInputContentData = toHashData(input);
-        const hashAbcContentData = toHashData(abcPath);
+        const hashInputContentData: any = toHashData(input);
+        const hashAbcContentData: any = toHashData(abcPath);
        if (jsonObject[input] === hashInputContentData && jsonObject[abcPath] === hashAbcContentData) {
          updateJsonObject[input] = hashInputContentData;
          updateJsonObject[abcPath] = hashAbcContentData;
@@ -628,19 +629,19 @@ function filterIntermediateJsBundleByHashJson(buildPath: string, inputPaths: Fil

 function writeHashJson() {
  for (let i = 0; i < fileterIntermediateJsBundle.length; ++i) {
-    const input = fileterIntermediateJsBundle[i].path;
-    const abcPath = input.replace(/_.js$/, EXTNAME_ABC);
+    const input:string = fileterIntermediateJsBundle[i].path;
+    const abcPath: string = input.replace(/_.js$/, EXTNAME_ABC);
    if (!fs.existsSync(input) || !fs.existsSync(abcPath)) {
      logger.error(red, `ETS:ERROR ${input} is lost`, reset);
      continue;
    }
-    const hashInputContentData = toHashData(input);
-    const hashAbcContentData = toHashData(abcPath);
+    const hashInputContentData: any = toHashData(input);
+    const hashAbcContentData: any = toHashData(abcPath);
    hashJsonObject[input] = hashInputContentData;
    hashJsonObject[abcPath] = hashAbcContentData;
    fs.unlinkSync(input);
  }
-  const hashFilePath = genHashJsonPath(buildPathInfo);
+  const hashFilePath: string = genHashJsonPath(buildPathInfo);
  if (hashFilePath.length === 0) {
    return;
  }
@@ -656,8 +657,8 @@ function genHashJsonPath(buildPath: string) {
    }
    return path.join(process.env.cachePath, hashFile);
  } else if (buildPath.indexOf(ARK) >= 0) {
-    const dataTmps = buildPath.split(ARK);
-    const hashPath = path.join(dataTmps[0], ARK);
+    const dataTmps: string[] = buildPath.split(ARK);
+    const hashPath: string = path.join(dataTmps[0], ARK);
    if (!fs.existsSync(hashPath) || !fs.statSync(hashPath).isDirectory()) {
      logger.error(red, `ETS:ERROR hash path does not exist`, reset);
      return '';
@@ -22,14 +22,14 @@ const red: string = '\u001b[31m';
 const reset: string = '\u001b[39m';

 function js2abcByWorkers(jsonInput: string, cmd: string): Promise<void> {
-  const inputPaths = JSON.parse(jsonInput);
-  const inputs = [];
+  const inputPaths: any = JSON.parse(jsonInput);
+  const inputs: string[] = [];
  for (let i = 0; i < inputPaths.length; ++i) {
-    const input = inputPaths[i].tempFilePath;
+    const input: string = inputPaths[i].tempFilePath;
    inputs.push('"' + input + '"');
  }
-  const inputsStr = inputs.join(' ');
-  const singleCmd = `${cmd} ${inputsStr}`;
+  const inputsStr: string = inputs.join(' ');
+  const singleCmd: any = `${cmd} ${inputsStr}`;
  logger.debug('gen abc cmd is: ', singleCmd);
  try {
    childProcess.execSync(singleCmd);
@@ -15,19 +15,15 @@

 import ts from 'typescript';
 import {
-  BUILD_ON,
-  ESMODULE
+  BUILD_ON
 } from './pre_define';
 import { writeFileSyncByNode } from './utils';
-import { projectConfig } from '../main';

 export function processJs(program: ts.Program, ut = false): Function {
  return (context: ts.TransformationContext) => {
    return (node: ts.SourceFile) => {
      if (process.env.compiler === BUILD_ON) {
-        if (projectConfig.compileMode === ESMODULE && projectConfig.processTs === false) {
-          writeFileSyncByNode(node, false);
-        }
+        writeFileSyncByNode(node, false);
        return node;
      } else {
        return node;
@@ -6,7 +6,7 @@ import {
 } from './pre_define';

 module.exports = function processjs2file(source: string): string {
-  if (projectConfig.compileMode === ESMODULE
+  if (projectConfig.compileMode === ESMODULE && projectConfig.processTs === false
      && process.env.compilerType && process.env.compilerType === ARK) {
    writeFileSyncByString(this.resourcePath, source, false);
  }
@@ -43,7 +43,8 @@ import {
  SET_CONTROLLER_METHOD,
  JS_DIALOG,
  CUSTOM_DIALOG_CONTROLLER_BUILDER,
-  ESMODULE
+  ESMODULE,
+  ARK
 } from './pre_define';
 import {
  componentInfo,
@@ -87,7 +88,8 @@ export function processUISyntax(program: ts.Program, ut = false): Function {
      if (process.env.compiler === BUILD_ON) {
        if (!ut && (path.basename(node.fileName) === 'app.ets' || /\.ts$/.test(node.fileName))) {
          node = ts.visitEachChild(node, processResourceNode, context);
-          if (projectConfig.compileMode === 'ESMODULE' && projectConfig.processTs === true) {
+          if (projectConfig.compileMode === ESMODULE && projectConfig.processTs === true
+            && process.env.compilerType && process.env.compilerType === ARK) {
            writeFileSyncByNode(node, true);
          }
          return node;
@@ -105,7 +107,8 @@ export function processUISyntax(program: ts.Program, ut = false): Function {
        });
        node = ts.factory.updateSourceFile(node, statements);
        INTERFACE_NODE_SET.clear();
-        if (projectConfig.compileMode === ESMODULE && projectConfig.processTs === true) {
+        if (projectConfig.compileMode === ESMODULE && projectConfig.processTs === true
+          && process.env.compilerType && process.env.compilerType === ARK) {
          writeFileSyncByNode(node, true);
        }
        return node;
@@ -239,9 +239,9 @@ export function toUnixPath(data: string): string {
  return data;
 }

-export function toHashData(path: string) {
-  const content = fs.readFileSync(path);
-  const hash = createHash('sha256');
+export function toHashData(path: string): any {
+  const content: string = fs.readFileSync(path).toString();
+  const hash: any = createHash('sha256');
  hash.update(content);
  return hash.digest('hex');
 }
@@ -265,25 +265,25 @@ export function genTemporaryPath(filePath: string, projectPath: string, buildPat
    filePath = filePath.replace(/\.cjs$/, EXTNAME_JS);
  }
  projectPath = toUnixPath(projectPath);
-  const hapPath = toUnixPath(projectConfig.projectRootPath);
-  const tempFilePath = filePath.replace(hapPath, '');
+  const hapPath: string = toUnixPath(projectConfig.projectRootPath);
+  const tempFilePath: string = filePath.replace(hapPath, '');

  if (checkNodeModulesFile(filePath, projectPath)) {
-    const fakeNodeModulesPath = toUnixPath(path.resolve(projectConfig.projectRootPath, NODE_MODULES));
-    const dataTmps = tempFilePath.split(NODE_MODULES);
-    let output:string = '';
+    const fakeNodeModulesPath: string = toUnixPath(path.resolve(projectConfig.projectRootPath, NODE_MODULES));
+    const dataTmps: string[] = tempFilePath.split(NODE_MODULES);
+    let output: string = '';
    if (filePath.indexOf(fakeNodeModulesPath) === -1) {
-      const sufStr = dataTmps[dataTmps.length - 1];
+      const sufStr: string = dataTmps[dataTmps.length - 1];
      output = path.join(buildPath, TEMPRARY, NODE_MODULES, MAIN, sufStr);
    } else {
-      const sufStr = dataTmps[dataTmps.length - 1];
+      const sufStr: string = dataTmps[dataTmps.length - 1];
      output = path.join(buildPath, TEMPRARY, NODE_MODULES, AUXILIARY, sufStr);
    }
    return output;
  }

  if (filePath.indexOf(projectPath) !== -1) {
-    const sufStr = filePath.replace(projectPath, '');
+    const sufStr: string = filePath.replace(projectPath, '');
    const output: string = path.join(buildPath, TEMPRARY, sufStr);
    return output;
  }
@@ -300,26 +300,26 @@ export function genBuildPath(filePath: string, projectPath: string, buildPath: s
    filePath = filePath.replace(/\.cjs$/, EXTNAME_JS);
  }
  projectPath = toUnixPath(projectPath);
-  const hapPath = toUnixPath(projectConfig.projectRootPath);
-  const tempFilePath = filePath.replace(hapPath, '');
+  const hapPath: string = toUnixPath(projectConfig.projectRootPath);
+  const tempFilePath: string = filePath.replace(hapPath, '');

  if (checkNodeModulesFile(filePath, projectPath)) {
    filePath = toUnixPath(filePath);
-    const fakeNodeModulesPath = toUnixPath(path.resolve(projectConfig.projectRootPath, NODE_MODULES));
-    const dataTmps = tempFilePath.split(NODE_MODULES);
-    let output:string = '';
+    const fakeNodeModulesPath: string = toUnixPath(path.resolve(projectConfig.projectRootPath, NODE_MODULES));
+    const dataTmps: string[] = tempFilePath.split(NODE_MODULES);
+    let output: string = '';
    if (filePath.indexOf(fakeNodeModulesPath) === -1) {
-      const sufStr = dataTmps[dataTmps.length - 1];
+      const sufStr: string = dataTmps[dataTmps.length - 1];
      output = path.join(projectConfig.nodeModulesPath, ZERO, sufStr);
    } else {
-      const sufStr = dataTmps[dataTmps.length - 1];
+      const sufStr: string = dataTmps[dataTmps.length - 1];
      output = path.join(projectConfig.nodeModulesPath, ONE, sufStr);
    }
    return output;
  }

  if (filePath.indexOf(projectPath) !== -1) {
-    const sufStr = filePath.replace(projectPath, '');
+    const sufStr: string = filePath.replace(projectPath, '');
    const output: string = path.join(buildPath, sufStr);
    return output;
  }
@@ -330,17 +330,17 @@ export function genBuildPath(filePath: string, projectPath: string, buildPath: s
 export function checkNodeModulesFile(filePath: string, projectPath: string) {
  filePath = toUnixPath(filePath);
  projectPath = toUnixPath(projectPath);
-  const hapPath = toUnixPath(projectConfig.projectRootPath);
-  const tempFilePath = filePath.replace(hapPath, '');
+  const hapPath: string = toUnixPath(projectConfig.projectRootPath);
+  const tempFilePath: string = filePath.replace(hapPath, '');
  if (tempFilePath.indexOf(NODE_MODULES) !== -1) {
-    const fakeNodeModulesPath = toUnixPath(path.resolve(projectConfig.projectRootPath, NODE_MODULES));
+    const fakeNodeModulesPath: string = toUnixPath(path.resolve(projectConfig.projectRootPath, NODE_MODULES));
    if (filePath.indexOf(fakeNodeModulesPath) !== -1) {
      return true;
    }
    if (projectConfig.modulePathMap) {
      for (const key in projectConfig.modulePathMap) {
-        const value = projectConfig.modulePathMap[key];
-        const fakeModuleNodeModulesPath = toUnixPath(path.resolve(value, NODE_MODULES));
+        const value: string = projectConfig.modulePathMap[key];
+        const fakeModuleNodeModulesPath: string = toUnixPath(path.resolve(value, NODE_MODULES));
        if (filePath.indexOf(fakeModuleNodeModulesPath) !== -1) {
          return true;
        }
@@ -354,27 +354,27 @@ export function checkNodeModulesFile(filePath: string, projectPath: string) {
 export function mkdirsSync(dirname: string): boolean {
  if (fs.existsSync(dirname)) {
    return true;
-  } else {
-    if (mkdirsSync(path.dirname(dirname))) {
-      fs.mkdirSync(dirname);
-      return true;
-    }
+  } else if (mkdirsSync(path.dirname(dirname))) {
+    fs.mkdirSync(dirname);
+    return true;
  }
+
  return false;
 }

-export function writeFileSyncByString(sourcePath: string, sourceCode: string, toTsFile: boolean) {
+export function writeFileSyncByString(sourcePath: string, sourceCode: string, toTsFile: boolean): void {
  const temporaryFile: string = genTemporaryPath(sourcePath, projectConfig.projectPath, process.env.cachePath, toTsFile);
  if (temporaryFile.length === 0) {
    return;
  }
  mkdirsSync(path.dirname(temporaryFile));
  fs.writeFileSync(temporaryFile, sourceCode);
+  return;
 }

 export function writeFileSyncByNode(node: ts.SourceFile, toTsFile: boolean) {
  if (toTsFile) {
-    const newStatements = [];
+    const newStatements: ts.Node[] = [];
    const tsIgnoreNode: ts.Node = ts.factory.createExpressionStatement(ts.factory.createIdentifier(TS_NOCHECK));
    newStatements.push(tsIgnoreNode);
    if (node.statements && node.statements.length) {
@@ -383,43 +383,7 @@ export function writeFileSyncByNode(node: ts.SourceFile, toTsFile: boolean) {

    node = ts.factory.updateSourceFile(node, newStatements);
  }
-  const printer: ts.Printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-  const options : ts.CompilerOptions = {
-    sourceMap: true
-  };
-  const mapOpions = {
-    sourceMap: true,
-    inlineSourceMap: false,
-    inlineSources: false,
-    sourceRoot: '',
-    mapRoot: '',
-    extendedDiagnostics: false
-  };
-  const host = ts.createCompilerHost(options);
-  const fileName = node.fileName;
-  // @ts-ignore
-  const sourceMapGenerator = ts.createSourceMapGenerator(
-    host,
-    // @ts-ignore
-    ts.getBaseFileName(fileName),
-    '',
-    '',
-    mapOpions
-  );
-  // @ts-ignore
-  const writer = ts.createTextWriter(
-    // @ts-ignore
-    ts.getNewLineCharacter({newLine: ts.NewLineKind.LineFeed, removeComments: false}));
-  printer['writeFile'](node, writer, sourceMapGenerator);
-  const sourceMapJson = sourceMapGenerator.toJSON();
-  sourceMapJson['sources'] = [fileName];
-  const result: string = writer.getText();
-  let content: string = result;
-  content = processSystemApi(content, true);
-  if (toTsFile) {
-    content = result.replace(`${TS_NOCHECK};`, TS_NOCHECK);
-  }
-  const sourceMapContent = JSON.stringify(sourceMapJson);
+  const mixedInfo: {content: string, sourceMapContent: string} = genContentAndSourceMapInfo(node, toTsFile);
  let temporaryFile: string = genTemporaryPath(node.fileName, projectConfig.projectPath, process.env.cachePath, toTsFile);
  if (temporaryFile.length === 0) {
    return;
@@ -439,12 +403,57 @@ export function writeFileSyncByNode(node: ts.SourceFile, toTsFile: boolean) {
    }
  }
  mkdirsSync(path.dirname(temporaryFile));
-  fs.writeFileSync(temporaryFile, content);
+  fs.writeFileSync(temporaryFile, mixedInfo.content);
  if (temporarySourceMapFile.length > 0 && projectConfig.buildArkMode === 'debug') {
-    fs.writeFileSync(temporarySourceMapFile, sourceMapContent);
+    fs.writeFileSync(temporarySourceMapFile, mixedInfo.sourceMapContent);
  }
 }

+function genContentAndSourceMapInfo(node: ts.SourceFile, toTsFile: boolean): {content: string, sourceMapContent: string} {
+  const printer: ts.Printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const options: ts.CompilerOptions = {
+    sourceMap: true
+  };
+  const mapOpions: any = {
+    sourceMap: true,
+    inlineSourceMap: false,
+    inlineSources: false,
+    sourceRoot: '',
+    mapRoot: '',
+    extendedDiagnostics: false
+  };
+  const host: ts.CompilerHost = ts.createCompilerHost(options);
+  const fileName: string = node.fileName;
+  // @ts-ignore
+  const sourceMapGenerator: any = ts.createSourceMapGenerator(
+    host,
+    // @ts-ignore
+    ts.getBaseFileName(fileName),
+    '',
+    '',
+    mapOpions
+  );
+  // @ts-ignore
+  const writer: any = ts.createTextWriter(
+    // @ts-ignore
+    ts.getNewLineCharacter({newLine: ts.NewLineKind.LineFeed, removeComments: false}));
+  printer['writeFile'](node, writer, sourceMapGenerator);
+  const sourceMapJson: any = sourceMapGenerator.toJSON();
+  sourceMapJson['sources'] = [fileName];
+  const result: string = writer.getText();
+  let content: string = result;
+  content = processSystemApi(content, true);
+  if (toTsFile) {
+    content = result.replace(`${TS_NOCHECK};`, TS_NOCHECK);
+  }
+  const sourceMapContent: string = JSON.stringify(sourceMapJson);
+
+  return {
+    content: content,
+    sourceMapContent: sourceMapContent
+  };
+}
+
 export function genAbcFileName(temporaryFile: string): string {
  let abcFile: string = temporaryFile;
  if (temporaryFile.endsWith(EXTNAME_TS)) {
@@ -79,10 +79,16 @@ function initConfig(config) {
                transpileOnly: true,
                configFile: path.resolve(__dirname, 'tsconfig.json'),
                getCustomTransformers(program) {
-                  return {
+                  let transformerOperation = {
                    before: [processUISyntax(program)],
-                    after: [processJs(program)]
+                    after: []
                  };
+                  if (projectConfig.compileMode === 'esmodule' && projectConfig.processTs === false
+                  && process.env.compilerType && process.env.compilerType === 'ark') {
+                    transformerOperation.after.push(processJs(program));
+                  }
+
+                  return transformerOperation;
                },
                ignoreDiagnostics: IGNORE_ERROR_CODE
              }