@cocos/ccbuild 2.0.0-alpha.2 → 2.0.1

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

@@ -78,6 +78,7 @@ const dedent_1 = __importDefault(require("dedent"));
 const glob_1 = require("glob");
 const field_decorator_helper_1 = require("./field-decorator-helper");
 const external_wasm_loader_1 = require("./plugins/external-wasm-loader");
+const node_module_loader_1 = require("./plugins/node-module-loader");
 var babel = transformer_1.babel.core;
 var t = babel.types;
 var traverse = babel.traverse;
@@ -88,14 +89,6 @@ class EngineBuilder {
     this._entries = [];
     this._entriesForPass2 = new Set();
     this._virtual2code = {};
-    this._feature2NodeModule = {
-      'dragon-bones': '@cocos/dragonbones-js',
-      'physics-2d-box2d': '@cocos/box2d',
-      'physics-cannon': '@cocos/cannon',
-      'physics-physx': '@cocos/physx',
-      'physics-ammo': '@cocos/bullet'
-    };
-    this._nodeModules = [];
     this._virtualOverrides = {};
     this._buildResult = {};
     this._resolveExtension = ['.ts', '.js', '.json']; // not an option
@@ -106,9 +99,9 @@ class EngineBuilder {
       Path: 'PathAlias',
       struct: 'structAlias'
     };
-    this._filedDecoratorHelper = new field_decorator_helper_1.FiledDecoratorHelper();
+    this._fieldDecoratorHelper = new field_decorator_helper_1.FieldDecoratorHelper();
     this._plugins = [];
-    this._excludeTransform = [/external\:/];
+    this._excludeTransform = [/external:/];
   }
   build(options) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -116,18 +109,23 @@ class EngineBuilder {
         root
       } = options;
       this._buildResult = {};
-      const handleIdList = idList => {
-        for (let id of idList) {
-          const handleResult = this._handleId(id);
+      const handleIdList = idList => __awaiter(this, void 0, void 0, function* () {
+        for (const id of idList) {
+          const handleResult = yield this._handleId(id);
           this._buildResult[handleResult.file] = handleResult;
         }
-      };
+      });
+      this._initPlugins(options);
+      yield this._initOptions(options);
+      for (const plugin of this._plugins) {
+        if (plugin.buildStart) {
+          yield plugin.buildStart();
+        }
+      }
       // pass1: build ts for native engine
       console.log('[Build Engine]: pass1 - traverse and compile modules');
       console.time('pass1');
-      this._initPlugins(options);
-      yield this._initOptions(options);
-      handleIdList(this._entries);
+      yield handleIdList(this._entries);
       console.timeEnd('pass1');
       // pass2: build web version for jsb type declarations
       console.log('[Build Engine]: pass2 - apply jsb interface info');
@@ -145,7 +143,7 @@ class EngineBuilder {
       }
       console.timeEnd('pass2');
       if (options.outDir) {
-        for (let file in this._buildResult) {
+        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');
@@ -157,18 +155,22 @@ class EngineBuilder {
         console.timeEnd('pass3');
         this._buildIndex();
         yield this._copyTypes();
-        // this._addNodeModulesDeps();  // TODO: support node modules building
       }
-
+      for (const plugin of this._plugins) {
+        if (plugin.buildEnd) {
+          yield plugin.buildEnd();
+        }
+      }
       return this._buildResult;
     });
   }
   _initPlugins(options) {
-    this._plugins.push((0, external_wasm_loader_1.externalWasmLoaderFactory)({
+    this._plugins.push((0, node_module_loader_1.nodeModuleLoaderFactory)(), (0, external_wasm_loader_1.externalWasmLoaderFactory)({
       engineRoot: options.root
     }));
   }
   _initOptions(options) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
       this._options = options;
       const {
@@ -179,23 +181,16 @@ class EngineBuilder {
       } = options;
       const statsQuery = yield stats_query_1.StatsQuery.create(root);
       const constantManager = statsQuery.constantManager;
-      if (options.features) {
-        const featureUnits = statsQuery.getUnitsOfFeatures(options.features);
-        this._entries = featureUnits.map(fu => (0, utils_1.formatPath)(statsQuery.getFeatureUnitFile(fu)));
-        options.features.forEach(feature => {
-          const nodeModule = this._feature2NodeModule[feature];
-          nodeModule && this._nodeModules.push(nodeModule);
-        });
-      } else {
-        const featureUnits = statsQuery.getFeatureUnits();
-        this._entries = featureUnits.map(fu => (0, utils_1.formatPath)(statsQuery.getFeatureUnitFile(fu)));
-        this._nodeModules.push(...Object.values(this._feature2NodeModule));
-      }
+      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,
@@ -212,7 +207,7 @@ class EngineBuilder {
         const tsconfig = json5.parse(tsconfigContent);
         const compilerOptions = tsconfig.compilerOptions;
         if (compilerOptions && compilerOptions.baseUrl && compilerOptions.paths) {
-          for (let [key, paths] of Object.entries(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]));
           }
         }
@@ -222,53 +217,52 @@ class EngineBuilder {
         mode,
         flags: flagConfig
       });
-      this._virtual2code[this._filedDecoratorHelper.getModuleName()] = this._filedDecoratorHelper.genModuleSource();
-      // TODO: resolve node modules
-      this._virtual2code['@cocos/box2d'] = 'export {}';
-      this._virtual2code['@cocos/bullet'] = 'export {}';
-      this._virtual2code['@cocos/cannon'] = 'export {}';
-      for (let virtualName in this._virtual2code) {
+      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(id, importer) {
-    const resolvedId = this._resolve(id, importer);
-    if (typeof resolvedId === 'undefined') {
-      throw new Error(`Cannot resolve module id: ${id} ${importer ? `in file ${importer}` : ''}`);
-    }
-    const code = this._load(resolvedId);
-    if (typeof code === 'undefined') {
-      throw new Error(`Cannot load module: ${resolvedId} ${importer ? `in file ${importer}` : ''}`);
-    }
-    let overrideId = this._getOverrideId(id, 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 transformResult = this._transform(resolvedId, code);
-    const handleResult = this._buildResult[file] = {
-      code: transformResult.code,
-      file,
-      originalId: id,
-      resolvedId,
-      map: transformResult.map
-    };
-    transformResult.depIdList.forEach(id => {
-      const handleResult = this._handleId(id, file);
-      this._buildResult[handleResult.file] = handleResult;
+    return __awaiter(this, void 0, void 0, function* () {
+      const resolvedId = yield this._resolve(id, importer);
+      if (typeof resolvedId === 'undefined') {
+        throw new Error(`Cannot resolve module id: ${id} ${importer ? `in file ${importer}` : ''}`);
+      }
+      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(id, 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: id,
+        resolvedId,
+        map: transformResult.map
+      };
+      return handleResult;
     });
-    return handleResult;
   }
   _getOverrideId(id, importer) {
     var _a;
     let overrideId;
-    for (let p of this._plugins) {
+    for (const p of this._plugins) {
       overrideId = (_a = p.transformId) === null || _a === void 0 ? void 0 : _a.call(p, id, importer);
       if (overrideId) {
         return overrideId;
@@ -292,28 +286,28 @@ class EngineBuilder {
   }
   _resolve(id, importer) {
     var _a, _b;
-    for (let p of this._plugins) {
-      const resolvedId = (_a = p.resolve) === null || _a === void 0 ? void 0 : _a.call(p, id, importer);
-      if (resolvedId) {
-        return resolvedId;
+    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;
+        }
       }
-    }
-    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 (this._nodeModules.includes(id)) {
-      return id; // node module only use bare specifier as module 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));
@@ -333,33 +327,27 @@ class EngineBuilder {
   }
   _load(id) {
     var _a;
-    for (let p of this._plugins) {
-      const loadedCode = (_a = p.load) === null || _a === void 0 ? void 0 : _a.call(p, id);
-      if (loadedCode) {
-        return loadedCode;
+    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};`;
+      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];
       }
-      return code;
-    } else if (this._virtualOverrides[id]) {
-      return this._virtual2code[id];
-    }
+    });
   }
-  _transform(file, code) {
-    file = (0, utils_1.formatPath)(file);
-    for (let ex of this._excludeTransform) {
-      if (ex.test(file)) {
-        return {
-          code,
-          depIdList: []
-        };
-      }
-    }
+  _getDepIdList(file, code) {
     const depIdList = [];
+    // eg. zlib.js dependent on zlib.d.ts
     if (ps.extname(file) === '.js') {
       const dtsFile = (0, utils_1.toExtensionLess)(file) + '.d.ts';
       if (fs.existsSync(dtsFile)) {
@@ -368,174 +356,208 @@ class EngineBuilder {
     }
 
     const importExportVisitor = path => {
-      // @ts-ignore
+      // @ts-expect-error TODO: fix type
       const source = path.node.source;
       if (source) {
         const specifier = source.value;
         // add dependency
-        if (!this._nodeModules.includes(specifier)) {
-          // don't load node modules, we post install the modules in OH project
-          depIdList.push(specifier);
-        }
-        // 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 to transform specifier
-          traverse(path.node, {
-            StringLiteral(path) {
-              path.replaceWith(babel.types.stringLiteral(relativePath));
-              path.skip();
-            }
-          }, path.scope);
-        }
+        depIdList.push(specifier);
       }
-      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)));
-        }
-      };
-      path.traverse({
-        ExportSpecifier: importExportSpecifier,
-        ImportSpecifier: importExportSpecifier
-      });
     };
-    const self = this;
-    const transformResult = babel.transformSync(code, {
+    const res = babel.parseSync(code, {
       configFile: false,
       plugins: [[pluginSyntaxTS], [syntaxDecorators, {
         version: '2018-09',
         decoratorsBeforeExport: true
-      }], [() => {
-        return {
-          name: 'custom-transform',
-          pre(file) {
-            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._filedDecoratorHelper.addHelper(pluginPass.file);
-                  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()])));
-                    }
-                  });
-                }
+      }]]
+    });
+    babel.traverse(res, {
+      ImportDeclaration: importExportVisitor,
+      ExportDeclaration: importExportVisitor
+    });
+    return depIdList;
+  }
+  _transform(file, code) {
+    return __awaiter(this, void 0, void 0, function* () {
+      file = (0, utils_1.formatPath)(file);
+      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();
               }
-            });
-          },
-          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'
-                  }];
+            }, 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)));
+          }
+        };
+        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()])));
+                      }
+                    });
+                  }
                 }
-              } 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));
-              }
+              });
             },
-            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-ignore
-              const name = calleePath.node.name;
-              if (name) {
-                const alias = self._renameMap[name];
-                if (typeof alias === 'string') {
-                  calleePath.replaceWith(t.identifier(alias));
+            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));
                 }
-              }
-            },
-            TSTypeAnnotation(path) {
-              // @ts-ignore
-              const typeName = path.node.typeAnnotation.typeName;
-              const childPath = path.get('typeAnnotation');
-              if (typeName) {
-                const name = typeName.name;
+              },
+              ClassDeclaration(path) {
+                const idPath = path.get('id');
+                const name = idPath.node.name;
                 const alias = self._renameMap[name];
                 if (typeof alias === 'string') {
-                  path.replaceWith(t.tsTypeAnnotation({
-                    type: 'TSExpressionWithTypeArguments',
-                    expression: t.identifier(alias)
-                  }));
+                  idPath.replaceWith(t.identifier(alias));
                 }
-              } else if (childPath.type === 'TSLiteralType') {
-                const literalPath = childPath.get('literal');
-                if (literalPath.type === 'TemplateLiteral') {
-                  path.replaceWith(t.tsTypeAnnotation(t.tsStringKeyword()));
+              },
+              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));
+                  }
                 }
-              }
-            },
-            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));
+              },
+              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)
+                    }));
                   }
-                } else if (path.parent.type === 'MemberExpression' || path.parent.type === 'OptionalMemberExpression') {
-                  if (path.parent.property !== 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 === '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;
+                }
+              },
+              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);
                   }
-                  path.replaceWith(newIdentifier);
                 }
               }
             }
-          }
-        };
-      }]]
+          };
+        }]]
+      });
+      if (needFieldHelperModule) {
+        yield this._handleId(this._fieldDecoratorHelper.getModuleName(), file);
+      }
+      return {
+        code: transformResult === null || transformResult === void 0 ? void 0 : transformResult.code
+      };
     });
-    return {
-      code: transformResult === null || transformResult === void 0 ? void 0 : transformResult.code,
-      depIdList
-    };
   }
   _lintImport(lintFiles, verbose = false) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -545,11 +567,11 @@ class EngineBuilder {
         resolvePluginsRelativeTo: __dirname,
         useEslintrc: false,
         baseConfig: {
-          parser: "@typescript-eslint/parser",
-          plugins: ["@typescript-eslint", "unused-imports"],
+          parser: '@typescript-eslint/parser',
+          plugins: ['@typescript-eslint', 'unused-imports'],
           rules: {
-            "@typescript-eslint/consistent-type-imports": "error",
-            "unused-imports/no-unused-imports": "error"
+            '@typescript-eslint/consistent-type-imports': 'error',
+            'unused-imports/no-unused-imports': 'error'
           }
         }
       });
@@ -603,8 +625,8 @@ class EngineBuilder {
       if (!outDir) {
         return;
       }
-      const dtsFiles = yield (0, glob_1.glob)((0, utils_1.formatPath)(ps.join(root, './@types/**/*.d.ts')));
-      for (let file of dtsFiles) {
+      const dtsFiles = glob_1.glob.sync((0, utils_1.formatPath)(ps.join(root, './@types/**/*.d.ts')));
+      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));
@@ -618,33 +640,5 @@ class EngineBuilder {
       fs.outputFileSync(targetDomDts, code, 'utf8');
     });
   }
-  _addNodeModulesDeps() {
-    const {
-      outDir
-    } = this._options;
-    if (!outDir) {
-      return;
-    }
-    const pkgFile = (0, utils_1.formatPath)(ps.join(outDir, '..',
-    // src
-    '..',
-    // cocos
-    '..',
-    // ets
-    '..',
-    // main
-    '..',
-    // src
-    '..',
-    // entry
-    'package.json'));
-    if (!fs.existsSync(pkgFile)) {
-      return;
-    }
-    const jsonObj = fs.readJSONSync(pkgFile);
-    console.log(jsonObj);
-    // TODO
-  }
 }
-
 exports.EngineBuilder = EngineBuilder;