@cocos/ccbuild 2.2.0 → 2.2.2

package/modules/build-engine/lib/engine-ts/engine-builder.js

@@ -31,33 +31,6 @@ var __importStar = this && this.__importStar || function (mod) {
   __setModuleDefault(result, mod);
   return result;
 };
-var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
 var __importDefault = this && this.__importDefault || function (mod) {
   return mod && mod.__esModule ? mod : {
     "default": mod
@@ -105,173 +78,165 @@ class EngineBuilder {
     this._excludeTransform = [/native\/external\//];
     this._handledCache = {};
   }
-  build(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const {
-        root
-      } = options;
-      this._buildResult = {};
-      const handleIdList = idList => __awaiter(this, void 0, void 0, function* () {
-        for (const id of idList) {
-          const handleResult = yield this._handleId(id);
-          if (handleResult) {
-            this._buildResult[handleResult.file] = handleResult;
-          }
-        }
-      });
-      yield this._initOptions(options);
-      yield this._initPlugins(options);
-      for (const plugin of this._plugins) {
-        if (plugin.buildStart) {
-          yield plugin.buildStart();
+  async build(options) {
+    const {
+      root
+    } = options;
+    this._buildResult = {};
+    const handleIdList = async idList => {
+      for (const id of idList) {
+        const handleResult = await this._handleId(id);
+        if (handleResult) {
+          this._buildResult[handleResult.file] = handleResult;
         }
       }
-      // pass1: build ts for native engine
-      console.log('[Build Engine]: pass1 - traverse and compile modules');
-      console.time('pass1');
-      yield handleIdList(this._entries);
-      console.timeEnd('pass1');
-      // pass2: build web version for jsb type declarations
-      console.log('[Build Engine]: pass2 - apply jsb interface info');
-      console.time('pass2');
-      this._handledCache = {}; // clear cache
-      while (this._entriesForPass2.size !== 0) {
-        const entries2 = Array.from(this._entriesForPass2);
-        this._entriesForPass2.clear();
-        this._moduleOverrides = Object.entries(this._moduleOverrides).reduce((result, [k, v]) => {
-          if (!fs.existsSync(k) || !entries2.includes(k)) {
-            result[k] = v;
-          }
-          return result;
-        }, {});
-        yield handleIdList(entries2);
-      }
-      console.timeEnd('pass2');
-      if (options.outDir) {
-        for (const file in this._buildResult) {
-          const res = this._buildResult[file];
-          const output = ps.join(options.outDir, ps.relative(root, file));
-          fs.outputFileSync(output, res.code, 'utf8');
-        }
-        this._buildIndex();
-        yield this._copyTypes();
+    };
+    await this._initOptions(options);
+    await this._initPlugins(options);
+    for (const plugin of this._plugins) {
+      if (plugin.buildStart) {
+        await plugin.buildStart();
       }
-      for (const plugin of this._plugins) {
-        if (plugin.buildEnd) {
-          yield plugin.buildEnd();
+    }
+    // pass1: build ts for native engine
+    console.log('[Build Engine]: pass1 - traverse and compile modules');
+    console.time('pass1');
+    await handleIdList(this._entries);
+    console.timeEnd('pass1');
+    // pass2: build web version for jsb type declarations
+    console.log('[Build Engine]: pass2 - apply jsb interface info');
+    console.time('pass2');
+    this._handledCache = {}; // clear cache
+    while (this._entriesForPass2.size !== 0) {
+      const entries2 = Array.from(this._entriesForPass2);
+      this._entriesForPass2.clear();
+      this._moduleOverrides = Object.entries(this._moduleOverrides).reduce((result, [k, v]) => {
+        if (!fs.existsSync(k) || !entries2.includes(k)) {
+          result[k] = v;
         }
+        return result;
+      }, {});
+      await handleIdList(entries2);
+    }
+    console.timeEnd('pass2');
+    if (options.outDir) {
+      for (const file in this._buildResult) {
+        const res = this._buildResult[file];
+        const output = ps.join(options.outDir, ps.relative(root, file));
+        fs.outputFileSync(output, res.code, 'utf8');
+      }
+      this._buildIndex();
+      await this._copyTypes();
+    }
+    for (const plugin of this._plugins) {
+      if (plugin.buildEnd) {
+        await plugin.buildEnd();
       }
-      return this._buildResult;
-    });
+    }
+    return this._buildResult;
   }
-  _initPlugins(options) {
+  async _initPlugins(options) {
     var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-      this._moduleQuery = new modularize_1.ModuleQuery({
-        engine: options.root,
-        platform: options.platform
-      });
-      this._plugins.push((0, module_query_plugin_1.moduleQueryPlugin)(this._moduleQuery), (0, node_module_loader_1.nodeModuleLoaderFactory)(), (0, external_wasm_loader_1.externalWasmLoaderFactory)({
-        engineRoot: options.root,
-        outDir: options.outDir,
-        cullMeshopt: (_a = options.flagConfig.CULL_MESHOPT) !== null && _a !== void 0 ? _a : false
-      }));
+    this._moduleQuery = new modularize_1.ModuleQuery({
+      engine: options.root,
+      platform: options.platform
     });
+    this._plugins.push((0, module_query_plugin_1.moduleQueryPlugin)(this._moduleQuery), (0, node_module_loader_1.nodeModuleLoaderFactory)(), (0, external_wasm_loader_1.externalWasmLoaderFactory)({
+      engineRoot: options.root,
+      outDir: options.outDir,
+      cullMeshopt: (_a = options.flagConfig.CULL_MESHOPT) !== null && _a !== void 0 ? _a : false
+    }));
   }
-  _initOptions(options) {
+  async _initOptions(options) {
     var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-      this._options = options;
-      const {
-        root,
-        flagConfig,
-        platform,
-        mode
-      } = options;
-      const statsQuery = yield stats_query_1.StatsQuery.create(root);
-      const constantManager = statsQuery.constantManager;
-      const features = (_a = options.features) !== null && _a !== void 0 ? _a : statsQuery.getFeatures();
-      const featureUnits = statsQuery.getUnitsOfFeatures(features);
-      this._entries = featureUnits.map(fu => (0, utils_1.formatPath)(statsQuery.getFeatureUnitFile(fu)));
-      this._buildTimeConstants = constantManager.genBuildTimeConstants({
-        platform,
-        mode,
-        flags: flagConfig
-      });
-      const intrinsicFlags = statsQuery.getIntrinsicFlagsOfFeatures(features);
-      Object.assign(this._buildTimeConstants, intrinsicFlags);
-      this._moduleOverrides = statsQuery.evaluateModuleOverrides({
-        mode: options.mode,
-        platform: options.platform,
-        buildTimeConstants: this._buildTimeConstants
-      });
-      this._moduleOverrides = Object.entries(this._moduleOverrides).reduce((result, [k, v]) => {
-        result[(0, utils_1.formatPath)(k)] = (0, utils_1.formatPath)(v);
-        return result;
-      }, {});
-      // paths in tsconfig.json 
-      const tsconfigFile = ps.join(root, './tsconfig.json');
-      if (fs.existsSync(tsconfigFile)) {
-        const tsconfigContent = fs.readFileSync(tsconfigFile, 'utf8');
-        const tsconfig = json5.parse(tsconfigContent);
-        const compilerOptions = tsconfig.compilerOptions;
-        if (compilerOptions && compilerOptions.baseUrl && compilerOptions.paths) {
-          for (const [key, paths] of Object.entries(compilerOptions.paths)) {
-            this._moduleOverrides[key] = (0, utils_1.formatPath)(ps.join(ps.dirname(tsconfigFile), compilerOptions.baseUrl, paths[0]));
-          }
+    this._options = options;
+    const {
+      root,
+      flagConfig,
+      platform,
+      mode
+    } = options;
+    const statsQuery = await stats_query_1.StatsQuery.create(root);
+    const constantManager = statsQuery.constantManager;
+    const features = (_a = options.features) !== null && _a !== void 0 ? _a : statsQuery.getFeatures();
+    const featureUnits = statsQuery.getUnitsOfFeatures(features);
+    this._entries = featureUnits.map(fu => (0, utils_1.formatPath)(statsQuery.getFeatureUnitFile(fu)));
+    this._buildTimeConstants = constantManager.genBuildTimeConstants({
+      platform,
+      mode,
+      flags: flagConfig
+    });
+    const intrinsicFlags = statsQuery.getIntrinsicFlagsOfFeatures(features);
+    Object.assign(this._buildTimeConstants, intrinsicFlags);
+    this._moduleOverrides = statsQuery.evaluateModuleOverrides({
+      mode: options.mode,
+      platform: options.platform,
+      buildTimeConstants: this._buildTimeConstants
+    });
+    this._moduleOverrides = Object.entries(this._moduleOverrides).reduce((result, [k, v]) => {
+      result[(0, utils_1.formatPath)(k)] = (0, utils_1.formatPath)(v);
+      return result;
+    }, {});
+    // paths in tsconfig.json 
+    const tsconfigFile = ps.join(root, './tsconfig.json');
+    if (fs.existsSync(tsconfigFile)) {
+      const tsconfigContent = fs.readFileSync(tsconfigFile, 'utf8');
+      const tsconfig = json5.parse(tsconfigContent);
+      const compilerOptions = tsconfig.compilerOptions;
+      if (compilerOptions && compilerOptions.baseUrl && compilerOptions.paths) {
+        for (const [key, paths] of Object.entries(compilerOptions.paths)) {
+          this._moduleOverrides[key] = (0, utils_1.formatPath)(ps.join(ps.dirname(tsconfigFile), compilerOptions.baseUrl, paths[0]));
         }
       }
-      this._virtual2code['internal:constants'] = constantManager.exportStaticConstants({
-        platform,
-        mode,
-        flags: flagConfig
-      });
-      this._virtual2code[this._fieldDecoratorHelper.getModuleName()] = this._fieldDecoratorHelper.genModuleSource();
-      for (const virtualName in this._virtual2code) {
-        this._virtualOverrides[virtualName] = (0, utils_1.formatPath)(ps.join(root, '__virtual__', virtualName.replace(/:/g, '_'))) + '.ts';
-      }
+    }
+    this._virtual2code['internal:constants'] = constantManager.exportStaticConstants({
+      platform,
+      mode,
+      flags: flagConfig
     });
+    this._virtual2code[this._fieldDecoratorHelper.getModuleName()] = this._fieldDecoratorHelper.genModuleSource();
+    for (const virtualName in this._virtual2code) {
+      this._virtualOverrides[virtualName] = (0, utils_1.formatPath)(ps.join(root, '__virtual__', virtualName.replace(/:/g, '_'))) + '.ts';
+    }
   }
-  _handleId(idOrSource, importer) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const resolvedId = yield this._resolve(idOrSource, importer);
-      if (typeof resolvedId === 'undefined') {
-        throw new Error(`Cannot resolve module: ${idOrSource} ${importer ? `in file ${importer}` : ''}`);
-      }
-      // In case circular reference
-      if (this._handledCache[resolvedId]) {
-        return;
-      }
-      this._handledCache[resolvedId] = true;
-      const code = yield this._load(resolvedId);
-      if (typeof code === 'undefined') {
-        throw new Error(`Cannot load module: ${resolvedId} ${importer ? `in file ${importer}` : ''}`);
-      }
-      const overrideId = this._getOverrideId(idOrSource, importer);
-      // handle output file
-      let file = overrideId || resolvedId;
-      if (file.endsWith('.json')) {
-        file = file.slice(0, -5) + '.ts';
-      }
-      if (this._buildResult[file]) {
-        // skip cached file
-        return this._buildResult[file];
-      }
-      const depIdList = this._getDepIdList(file, code);
-      // we handle the dep module first, because we need to get the resolved dep id to transform the import specifier in current module.
-      for (const depId of depIdList) {
-        yield this._handleId(depId, file);
-      }
-      const transformResult = yield this._transform(resolvedId, code);
-      const handleResult = this._buildResult[file] = {
-        code: transformResult.code,
-        file,
-        originalId: idOrSource,
-        resolvedId,
-        map: transformResult.map
-      };
-      return handleResult;
-    });
+  async _handleId(idOrSource, importer) {
+    const resolvedId = await this._resolve(idOrSource, importer);
+    if (typeof resolvedId === 'undefined') {
+      throw new Error(`Cannot resolve module: ${idOrSource} ${importer ? `in file ${importer}` : ''}`);
+    }
+    // In case circular reference
+    if (this._handledCache[resolvedId]) {
+      return;
+    }
+    this._handledCache[resolvedId] = true;
+    const code = await this._load(resolvedId);
+    if (typeof code === 'undefined') {
+      throw new Error(`Cannot load module: ${resolvedId} ${importer ? `in file ${importer}` : ''}`);
+    }
+    const overrideId = this._getOverrideId(idOrSource, importer);
+    // handle output file
+    let file = overrideId || resolvedId;
+    if (file.endsWith('.json')) {
+      file = file.slice(0, -5) + '.ts';
+    }
+    if (this._buildResult[file]) {
+      // skip cached file
+      return this._buildResult[file];
+    }
+    const depIdList = this._getDepIdList(file, code);
+    // we handle the dep module first, because we need to get the resolved dep id to transform the import specifier in current module.
+    for (const depId of depIdList) {
+      await this._handleId(depId, file);
+    }
+    const transformResult = await this._transform(resolvedId, code);
+    const handleResult = this._buildResult[file] = {
+      code: transformResult.code,
+      file,
+      originalId: idOrSource,
+      resolvedId,
+      map: transformResult.map
+    };
+    return handleResult;
   }
   _getOverrideId(id, importer) {
     var _a;
@@ -298,30 +263,28 @@ class EngineBuilder {
     }
     return overrideId;
   }
-  _resolve(id, importer) {
+  async _resolve(id, importer) {
     var _a, _b;
-    return __awaiter(this, void 0, void 0, function* () {
-      for (const p of this._plugins) {
-        const resolvedId = yield (_a = p.resolve) === null || _a === void 0 ? void 0 : _a.call(p, id, importer);
-        if (resolvedId) {
-          return resolvedId;
-        }
+    for (const p of this._plugins) {
+      const resolvedId = await ((_a = p.resolve) === null || _a === void 0 ? void 0 : _a.call(p, id, importer));
+      if (resolvedId) {
+        return resolvedId;
       }
-      if (!importer) {
-        return id; // entry
-      } else if (id in this._virtualOverrides) {
-        return id; // virtual module does not have real fs path
-      } else if (id in this._moduleOverrides) {
-        return this._moduleOverrides[id];
-      } else if (ps.isAbsolute(id)) {
-        return id;
-      } else {
-        const resolved = this._resolveRelative(id, importer);
-        if (resolved) {
-          return (_b = this._moduleOverrides[resolved]) !== null && _b !== void 0 ? _b : resolved;
-        }
+    }
+    if (!importer) {
+      return id; // entry
+    } else if (id in this._virtualOverrides) {
+      return id; // virtual module does not have real fs path
+    } else if (id in this._moduleOverrides) {
+      return this._moduleOverrides[id];
+    } else if (ps.isAbsolute(id)) {
+      return id;
+    } else {
+      const resolved = this._resolveRelative(id, importer);
+      if (resolved) {
+        return (_b = this._moduleOverrides[resolved]) !== null && _b !== void 0 ? _b : resolved;
       }
-    });
+    }
   }
   _resolveRelative(id, importer) {
     const file = (0, utils_1.formatPath)(ps.join(ps.dirname(importer), id));
@@ -339,25 +302,23 @@ class EngineBuilder {
       }
     }
   }
-  _load(id) {
+  async _load(id) {
     var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-      for (const p of this._plugins) {
-        const loadedCode = yield (_a = p.load) === null || _a === void 0 ? void 0 : _a.call(p, id);
-        if (loadedCode) {
-          return loadedCode;
-        }
-      }
-      if (fs.existsSync(id)) {
-        let code = fs.readFileSync(id, 'utf8');
-        if (id.endsWith('.json')) {
-          code = `export default ${code};`;
-        }
-        return code;
-      } else if (this._virtualOverrides[id]) {
-        return this._virtual2code[id];
+    for (const p of this._plugins) {
+      const loadedCode = await ((_a = p.load) === null || _a === void 0 ? void 0 : _a.call(p, id));
+      if (loadedCode) {
+        return loadedCode;
       }
-    });
+    }
+    if (fs.existsSync(id)) {
+      let code = fs.readFileSync(id, 'utf8');
+      if (id.endsWith('.json')) {
+        code = `export default ${code};`;
+      }
+      return code;
+    } else if (this._virtualOverrides[id]) {
+      return this._virtual2code[id];
+    }
   }
   _getDepIdList(file, code) {
     let depIdList = [];
@@ -410,231 +371,229 @@ class EngineBuilder {
     depIdList = depIdList.filter((id, index) => depIdList.indexOf(id) === index);
     return depIdList;
   }
-  _transform(file, code) {
-    return __awaiter(this, void 0, void 0, function* () {
-      file = (0, utils_1.formatPath)(file);
-      (0, utils_1.asserts)(!file.includes('\\'), 'We should use posix path');
-      for (const ex of this._excludeTransform) {
-        if (ex.test(file)) {
-          return {
-            code
-          };
-        }
+  async _transform(file, code) {
+    file = (0, utils_1.formatPath)(file);
+    (0, utils_1.asserts)(!file.includes('\\'), 'We should use posix path');
+    for (const ex of this._excludeTransform) {
+      if (ex.test(file)) {
+        return {
+          code
+        };
       }
-      let needFieldHelperModule = false;
-      const importExportVisitor = path => {
-        // @ts-expect-error TODO: fix type
-        const source = path.node.source;
-        if (source) {
-          const specifier = source.value;
-          // transform import/export declaration if needed
-          const overrideId = this._getOverrideId(specifier, file);
-          if (overrideId) {
-            let relativePath = (0, utils_1.formatPath)(ps.relative(ps.dirname(file), overrideId));
-            if (!relativePath.startsWith('.')) {
-              relativePath = './' + relativePath;
-            }
-            if (ps.extname(relativePath) === '.ts') {
-              relativePath = relativePath.slice(0, -3); // remove '.ts'
-            }
-
-            traverse(path.node, {
-              StringLiteral(path) {
-                path.replaceWith(babel.types.stringLiteral(relativePath));
-                path.skip();
-              }
-            }, path.scope);
+    }
+    let needFieldHelperModule = false;
+    const importExportVisitor = path => {
+      // @ts-expect-error TODO: fix type
+      const source = path.node.source;
+      if (source) {
+        const specifier = source.value;
+        // transform import/export declaration if needed
+        const overrideId = this._getOverrideId(specifier, file);
+        if (overrideId) {
+          let relativePath = (0, utils_1.formatPath)(ps.relative(ps.dirname(file), overrideId));
+          if (!relativePath.startsWith('.')) {
+            relativePath = './' + relativePath;
           }
-        }
-        const importExportSpecifier = path => {
-          const name = path.node.local.name;
-          const alias = this._renameMap[name];
-          if (alias) {
-            path.replaceWith(babel.types.exportSpecifier(babel.types.identifier(alias), babel.types.identifier(alias)));
+          if (ps.extname(relativePath) === '.ts') {
+            relativePath = relativePath.slice(0, -3); // remove '.ts'
           }
-        };
-        path.traverse({
-          ExportSpecifier: importExportSpecifier,
-          ImportSpecifier: importExportSpecifier
-        });
+
+          traverse(path.node, {
+            StringLiteral(path) {
+              path.replaceWith(babel.types.stringLiteral(relativePath));
+              path.skip();
+            }
+          }, path.scope);
+        }
+      }
+      const importExportSpecifier = path => {
+        const name = path.node.local.name;
+        const alias = this._renameMap[name];
+        if (alias) {
+          path.replaceWith(babel.types.exportSpecifier(babel.types.identifier(alias), babel.types.identifier(alias)));
+        }
       };
-      // eslint-disable-next-line @typescript-eslint/no-this-alias
-      const self = this;
-      const transformResult = babel.transformSync(code, {
-        configFile: false,
-        plugins: [[pluginSyntaxTS], [syntaxDecorators, {
-          version: '2018-09',
-          decoratorsBeforeExport: true
-        }], [() => {
-          return {
-            name: 'custom-transform',
-            pre(file) {
-              // eslint-disable-next-line @typescript-eslint/no-this-alias
-              const pluginPass = this;
-              traverse(file.ast, {
-                ClassProperty(path) {
-                  const decoratorsPath = path.get('decorators');
-                  if (Array.isArray(decoratorsPath)) {
-                    const propertyValuePath = path.get('value');
-                    const helperIdentifier = self._fieldDecoratorHelper.addHelper(pluginPass.file);
-                    needFieldHelperModule = true;
-                    decoratorsPath.forEach(decPath => {
-                      const expPath = decPath.get('expression');
-                      const type = expPath.node.type;
-                      if (type === 'CallExpression') {
-                        const decName = expPath.node.callee.name;
-                        const args = expPath.node.arguments;
-                        decPath.replaceWith(t.decorator(t.callExpression(helperIdentifier, [t.identifier(decName), propertyValuePath.node ? t.arrowFunctionExpression([], propertyValuePath.node) : t.nullLiteral(), ...args])));
-                      } else if (type === 'Identifier') {
-                        const decName = expPath.node.name;
-                        decPath.replaceWith(t.decorator(t.callExpression(helperIdentifier, [t.identifier(decName), propertyValuePath.node ? t.arrowFunctionExpression([], propertyValuePath.node) : t.nullLiteral()])));
+      path.traverse({
+        ExportSpecifier: importExportSpecifier,
+        ImportSpecifier: importExportSpecifier
+      });
+    };
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    const transformResult = babel.transformSync(code, {
+      configFile: false,
+      plugins: [[pluginSyntaxTS], [syntaxDecorators, {
+        version: '2018-09',
+        decoratorsBeforeExport: true
+      }], [() => {
+        return {
+          name: 'custom-transform',
+          pre(file) {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const pluginPass = this;
+            traverse(file.ast, {
+              ClassProperty(path) {
+                const decoratorsPath = path.get('decorators');
+                if (Array.isArray(decoratorsPath)) {
+                  const propertyValuePath = path.get('value');
+                  const helperIdentifier = self._fieldDecoratorHelper.addHelper(pluginPass.file);
+                  needFieldHelperModule = true;
+                  decoratorsPath.forEach(decPath => {
+                    const expPath = decPath.get('expression');
+                    const type = expPath.node.type;
+                    if (type === 'CallExpression') {
+                      const decName = expPath.node.callee.name;
+                      const args = expPath.node.arguments;
+                      decPath.replaceWith(t.decorator(t.callExpression(helperIdentifier, [t.identifier(decName), propertyValuePath.node ? t.arrowFunctionExpression([], propertyValuePath.node) : t.nullLiteral(), ...args])));
+                    } else if (type === 'Identifier') {
+                      const decName = expPath.node.name;
+                      decPath.replaceWith(t.decorator(t.callExpression(helperIdentifier, [t.identifier(decName), propertyValuePath.node ? t.arrowFunctionExpression([], propertyValuePath.node) : t.nullLiteral()])));
+                    }
+                  });
+                }
+              }
+            });
+          },
+          visitor: {
+            ImportDeclaration: importExportVisitor,
+            ExportDeclaration: importExportVisitor,
+            // TODO: here we rename class Rect and Path
+            CallExpression: path => {
+              if (path.node.callee.type === 'MemberExpression') {
+                const memberExpressionPath = path.get('callee');
+                const objectPath = memberExpressionPath.get('object');
+                const name = objectPath.node.name;
+                const alias = self._renameMap[name];
+                if (typeof alias === 'string' && path.node.callee.object.type === 'Identifier') {
+                  objectPath.replaceWith(t.identifier(alias));
+                }
+                // TODO: for now, OH doesn't support standard console interface,
+                // so we need to ignore the type checking for console call expressions.
+                else if (name === 'console') {
+                  path.node.leadingComments = [{
+                    type: 'CommentLine',
+                    value: ' @ts-ignore'
+                  }];
+                }
+              } else if (path.node.callee.type === 'Import') {
+                // TODO: for now, we transform `import('./xxx/xxx.js')` into `window.__cc_module_context__.import('./xxx/xxx.js')`
+                // we need to support import(`project://xxx`) in the future.
+                path.replaceWith(t.callExpression(t.memberExpression(t.memberExpression(t.identifier('window'), t.identifier('__cc_module_context__')), t.identifier('import')), path.node.arguments));
+                const arg0 = path.node.arguments[0];
+                if (arg0.type === 'StringLiteral') {
+                  const specifier = arg0.value;
+                  // transform import/export declaration if needed
+                  const overrideId = this._getOverrideId(specifier, file);
+                  if (overrideId) {
+                    let relativePath = (0, utils_1.formatPath)(ps.relative(ps.dirname(file), overrideId));
+                    if (!relativePath.startsWith('.')) {
+                      relativePath = './' + relativePath;
+                    }
+                    if (ps.extname(relativePath) === '.ts') {
+                      relativePath = relativePath.slice(0, -3); // remove '.ts'
+                    }
+
+                    traverse(path.node, {
+                      StringLiteral(path) {
+                        path.replaceWith(babel.types.stringLiteral(relativePath));
+                        path.skip();
                       }
-                    });
+                    }, path.scope);
                   }
                 }
-              });
+              }
             },
-            visitor: {
-              ImportDeclaration: importExportVisitor,
-              ExportDeclaration: importExportVisitor,
-              // TODO: here we rename class Rect and Path
-              CallExpression: path => {
-                if (path.node.callee.type === 'MemberExpression') {
-                  const memberExpressionPath = path.get('callee');
-                  const objectPath = memberExpressionPath.get('object');
-                  const name = objectPath.node.name;
-                  const alias = self._renameMap[name];
-                  if (typeof alias === 'string' && path.node.callee.object.type === 'Identifier') {
-                    objectPath.replaceWith(t.identifier(alias));
-                  }
-                  // TODO: for now, OH doesn't support standard console interface,
-                  // so we need to ignore the type checking for console call expressions.
-                  else if (name === 'console') {
-                    path.node.leadingComments = [{
-                      type: 'CommentLine',
-                      value: ' @ts-ignore'
-                    }];
-                  }
-                } else if (path.node.callee.type === 'Import') {
-                  // TODO: for now, we transform `import('./xxx/xxx.js')` into `window.__cc_module_context__.import('./xxx/xxx.js')`
-                  // we need to support import(`project://xxx`) in the future.
-                  path.replaceWith(t.callExpression(t.memberExpression(t.memberExpression(t.identifier('window'), t.identifier('__cc_module_context__')), t.identifier('import')), path.node.arguments));
-                  const arg0 = path.node.arguments[0];
-                  if (arg0.type === 'StringLiteral') {
-                    const specifier = arg0.value;
-                    // transform import/export declaration if needed
-                    const overrideId = this._getOverrideId(specifier, file);
-                    if (overrideId) {
-                      let relativePath = (0, utils_1.formatPath)(ps.relative(ps.dirname(file), overrideId));
-                      if (!relativePath.startsWith('.')) {
-                        relativePath = './' + relativePath;
-                      }
-                      if (ps.extname(relativePath) === '.ts') {
-                        relativePath = relativePath.slice(0, -3); // remove '.ts'
-                      }
-
-                      traverse(path.node, {
-                        StringLiteral(path) {
-                          path.replaceWith(babel.types.stringLiteral(relativePath));
-                          path.skip();
-                        }
-                      }, path.scope);
-                    }
-                  }
+            TSImportType: path => {
+              const specifier = path.node.argument.value;
+              // transform import/export declaration if needed
+              const overrideId = this._getOverrideId(specifier, file);
+              if (overrideId) {
+                let relativePath = (0, utils_1.formatPath)(ps.relative(ps.dirname(file), overrideId));
+                if (!relativePath.startsWith('.')) {
+                  relativePath = './' + relativePath;
+                }
+                if (ps.extname(relativePath) === '.ts') {
+                  relativePath = relativePath.slice(0, -3); // remove '.ts'
                 }
-              },
-              TSImportType: path => {
-                const specifier = path.node.argument.value;
-                // transform import/export declaration if needed
-                const overrideId = this._getOverrideId(specifier, file);
-                if (overrideId) {
-                  let relativePath = (0, utils_1.formatPath)(ps.relative(ps.dirname(file), overrideId));
-                  if (!relativePath.startsWith('.')) {
-                    relativePath = './' + relativePath;
-                  }
-                  if (ps.extname(relativePath) === '.ts') {
-                    relativePath = relativePath.slice(0, -3); // remove '.ts'
-                  }
 
-                  traverse(path.node, {
-                    StringLiteral(path) {
-                      path.replaceWith(babel.types.stringLiteral(relativePath));
-                      path.skip();
-                    }
-                  }, path.scope);
+                traverse(path.node, {
+                  StringLiteral(path) {
+                    path.replaceWith(babel.types.stringLiteral(relativePath));
+                    path.skip();
+                  }
+                }, path.scope);
+              }
+            },
+            ClassDeclaration(path) {
+              const idPath = path.get('id');
+              const name = idPath.node.name;
+              const alias = self._renameMap[name];
+              if (typeof alias === 'string') {
+                idPath.replaceWith(t.identifier(alias));
+              }
+            },
+            NewExpression(path) {
+              const calleePath = path.get('callee');
+              // @ts-expect-error TODO: fix type
+              const name = calleePath.node.name;
+              if (name) {
+                const alias = self._renameMap[name];
+                if (typeof alias === 'string') {
+                  calleePath.replaceWith(t.identifier(alias));
                 }
-              },
-              ClassDeclaration(path) {
-                const idPath = path.get('id');
-                const name = idPath.node.name;
+              }
+            },
+            TSTypeAnnotation(path) {
+              // @ts-expect-error TODO: fix type
+              const typeName = path.node.typeAnnotation.typeName;
+              const childPath = path.get('typeAnnotation');
+              if (typeName) {
+                const name = typeName.name;
                 const alias = self._renameMap[name];
                 if (typeof alias === 'string') {
-                  idPath.replaceWith(t.identifier(alias));
+                  path.replaceWith(t.tsTypeAnnotation({
+                    type: 'TSExpressionWithTypeArguments',
+                    expression: t.identifier(alias)
+                  }));
                 }
-              },
-              NewExpression(path) {
-                const calleePath = path.get('callee');
-                // @ts-expect-error TODO: fix type
-                const name = calleePath.node.name;
-                if (name) {
-                  const alias = self._renameMap[name];
-                  if (typeof alias === 'string') {
-                    calleePath.replaceWith(t.identifier(alias));
-                  }
+              } else if (childPath.type === 'TSLiteralType') {
+                const literalPath = childPath.get('literal');
+                if (literalPath.type === 'TemplateLiteral') {
+                  path.replaceWith(t.tsTypeAnnotation(t.tsStringKeyword()));
                 }
-              },
-              TSTypeAnnotation(path) {
-                // @ts-expect-error TODO: fix type
-                const typeName = path.node.typeAnnotation.typeName;
-                const childPath = path.get('typeAnnotation');
-                if (typeName) {
-                  const name = typeName.name;
-                  const alias = self._renameMap[name];
-                  if (typeof alias === 'string') {
-                    path.replaceWith(t.tsTypeAnnotation({
-                      type: 'TSExpressionWithTypeArguments',
-                      expression: t.identifier(alias)
-                    }));
+              }
+            },
+            Identifier(path) {
+              const name = path.node.name;
+              const alias = self._renameMap[name];
+              if (typeof alias === 'string') {
+                if (path.parent.type === 'ObjectProperty' || path.parent.type === 'TSPropertySignature') {
+                  if (path.parent.key !== path.node) {
+                    path.replaceWith(t.identifier(alias));
                   }
-                } else if (childPath.type === 'TSLiteralType') {
-                  const literalPath = childPath.get('literal');
-                  if (literalPath.type === 'TemplateLiteral') {
-                    path.replaceWith(t.tsTypeAnnotation(t.tsStringKeyword()));
+                } else if (path.parent.type === 'MemberExpression' || path.parent.type === 'OptionalMemberExpression') {
+                  if (path.parent.property !== path.node) {
+                    path.replaceWith(t.identifier(alias));
                   }
-                }
-              },
-              Identifier(path) {
-                const name = path.node.name;
-                const alias = self._renameMap[name];
-                if (typeof alias === 'string') {
-                  if (path.parent.type === 'ObjectProperty' || path.parent.type === 'TSPropertySignature') {
-                    if (path.parent.key !== path.node) {
-                      path.replaceWith(t.identifier(alias));
-                    }
-                  } else if (path.parent.type === 'MemberExpression' || path.parent.type === 'OptionalMemberExpression') {
-                    if (path.parent.property !== path.node) {
-                      path.replaceWith(t.identifier(alias));
-                    }
-                  } else if (!(path.parent.type === 'ClassMethod' && (path.parent.kind === 'get' || path.parent.kind === 'set' || path.parent.key === path.node)) && path.parent.type !== 'ClassProperty') {
-                    const newIdentifier = t.identifier(alias);
-                    if (path.node.typeAnnotation) {
-                      newIdentifier.typeAnnotation = path.node.typeAnnotation;
-                    }
-                    path.replaceWith(newIdentifier);
+                } else if (!(path.parent.type === 'ClassMethod' && (path.parent.kind === 'get' || path.parent.kind === 'set' || path.parent.key === path.node)) && path.parent.type !== 'ClassProperty') {
+                  const newIdentifier = t.identifier(alias);
+                  if (path.node.typeAnnotation) {
+                    newIdentifier.typeAnnotation = path.node.typeAnnotation;
                   }
+                  path.replaceWith(newIdentifier);
                 }
               }
             }
-          };
-        }]]
-      });
-      if (needFieldHelperModule) {
-        yield this._handleId(this._fieldDecoratorHelper.getModuleName(), file);
-      }
-      return {
-        code: transformResult === null || transformResult === void 0 ? void 0 : transformResult.code
-      };
+          }
+        };
+      }]]
     });
+    if (needFieldHelperModule) {
+      await this._handleId(this._fieldDecoratorHelper.getModuleName(), file);
+    }
+    return {
+      code: transformResult === null || transformResult === void 0 ? void 0 : transformResult.code
+    };
   }
   _buildIndex() {
     const {
@@ -668,47 +627,43 @@ class EngineBuilder {
       fs.outputFileSync(systemCCFile, systemCCContent, 'utf8');
     }
   }
-  _copyTypes() {
-    return __awaiter(this, void 0, void 0, function* () {
-      const {
-        root,
-        outDir
-      } = this._options;
-      if (!outDir) {
-        return;
-      }
-      let dtsFiles;
-      try {
-        const ccAmbientTypesQuery = yield this._requireEngineModules('@types/cc-ambient-types/query');
-        dtsFiles = ccAmbientTypesQuery.getDtsFiles();
-      } catch (e) {
-        // NOTE: if failed to resolve '@types/cc-ambient-types', we use the legacy way to copy dts files.
-        dtsFiles = glob_1.glob.sync((0, utils_1.formatPath)(ps.join(root, './@types/**/*.d.ts')));
-        const externalDtsFiles = glob_1.glob.sync((0, utils_1.formatPath)(ps.join(root, './native/external/**/*.d.ts')));
-        dtsFiles = dtsFiles.concat(externalDtsFiles);
-      }
-      for (const file of dtsFiles) {
-        const code = fs.readFileSync(file, 'utf8');
-        const relativePath = ps.relative(root, file);
-        const targetPath = (0, utils_1.formatPath)(ps.join(outDir, relativePath));
-        fs.outputFileSync(targetPath, code, 'utf8');
-      }
-      // copy lib.dom.d.ts
-      // we use 4.2 version of typescript
-      const originalDomDts = (0, utils_1.formatPath)(ps.join(__dirname, '../../../../static/lib.dom.d.ts'));
-      const targetDomDts = (0, utils_1.formatPath)(ps.join(outDir, '@types/lib.dom.d.ts'));
-      const code = fs.readFileSync(originalDomDts, 'utf8');
-      fs.outputFileSync(targetDomDts, code, 'utf8');
-    });
+  async _copyTypes() {
+    const {
+      root,
+      outDir
+    } = this._options;
+    if (!outDir) {
+      return;
+    }
+    let dtsFiles;
+    try {
+      const ccAmbientTypesQuery = await this._requireEngineModules('@types/cc-ambient-types/query');
+      dtsFiles = ccAmbientTypesQuery.getDtsFiles();
+    } catch (e) {
+      // NOTE: if failed to resolve '@types/cc-ambient-types', we use the legacy way to copy dts files.
+      dtsFiles = glob_1.glob.sync((0, utils_1.formatPath)(ps.join(root, './@types/**/*.d.ts')));
+      const externalDtsFiles = glob_1.glob.sync((0, utils_1.formatPath)(ps.join(root, './native/external/**/*.d.ts')));
+      dtsFiles = dtsFiles.concat(externalDtsFiles);
+    }
+    for (const file of dtsFiles) {
+      const code = fs.readFileSync(file, 'utf8');
+      const relativePath = ps.relative(root, file);
+      const targetPath = (0, utils_1.formatPath)(ps.join(outDir, relativePath));
+      fs.outputFileSync(targetPath, code, 'utf8');
+    }
+    // copy lib.dom.d.ts
+    // we use 4.2 version of typescript
+    const originalDomDts = (0, utils_1.formatPath)(ps.join(__dirname, '../../../../static/lib.dom.d.ts'));
+    const targetDomDts = (0, utils_1.formatPath)(ps.join(outDir, '@types/lib.dom.d.ts'));
+    const code = fs.readFileSync(originalDomDts, 'utf8');
+    fs.outputFileSync(targetDomDts, code, 'utf8');
   }
-  _requireEngineModules(moduleName) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const resolvedPath = yield this._moduleQuery.resolveExport(moduleName);
-      if (!resolvedPath) {
-        throw new Error(`Can't resolve engine module: ${moduleName}.`);
-      }
-      return require(resolvedPath);
-    });
+  async _requireEngineModules(moduleName) {
+    const resolvedPath = await this._moduleQuery.resolveExport(moduleName);
+    if (!resolvedPath) {
+      throw new Error(`Can't resolve engine module: ${moduleName}.`);
+    }
+    return require(resolvedPath);
   }
 }
 exports.EngineBuilder = EngineBuilder;