@hadss/turbo-trans-json-plugin 1.0.0-rc.1 → 1.0.0-rc.2

package/src/core/services/CodeGenerationService/generators/SendableClassGenerator.ts

@@ -13,8 +13,13 @@
  * limitations under the License.
  */
 
-import { ClassDeclaration, SourceFile } from 'ts-morph';
-import { ClassAnalysis, ClassDetails, Logger, PropertyAnalysis, PropertyKind, TypeKind, TypeStructure } from '../../..';
+import {
+  ClassDeclaration, ConstructorDeclaration, Decorator, Identifier, ImportDeclaration, ParameterDeclaration,
+  PropertyDeclaration, SourceFile
+} from 'ts-morph';
+import {
+  ClassAnalysis, ClassDetails, Logger, PropertyAnalysis, PropertyKind, TypeDependency, TypeKind, TypeStructure
+} from '../../..';
 import { ImportManager } from '../shared/ImportManager';
 import { ClassAnalyzer } from '../../../analyzers/ClassAnalyzer';
 import { TypeHandlerRegistry } from '../../../handlers';
@@ -64,7 +69,8 @@ export class SendableClassGenerator {
 
   private getOriginClassDeclaration(result: ClassAnalysis): ClassDeclaration {
     const originalContent = result.originalClass?.getFullText();
-    const copiedSourceFile = TsMorphUtil.getProject().createSourceFile('copied-file.ts', originalContent, { overwrite: true });
+    const copiedSourceFile = TsMorphUtil.getProject()
+      .createSourceFile('copied-file.ts', originalContent, { overwrite: true });
     return copiedSourceFile.getClassOrThrow(result.className);
   }
 
@@ -90,77 +96,93 @@ export class SendableClassGenerator {
   }
 
   private removeAllDecorators(classDecl: ClassDeclaration): void {
-    // 剔除类级别装饰器
+    this.removeClassDecorators(classDecl);
+    this.removePropertyDecorators(classDecl);
+    this.removeMethodDecorators(classDecl);
+  }
+
+  private removeClassDecorators(classDecl: ClassDeclaration): void {
     classDecl.getDecorators().forEach((decorator) => {
-      Logger.warn(
-        `Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`
-      );
-      decorator.remove();
+      this.logAndRemoveDecorator(decorator);
     });
+  }
 
-    // 剔除属性装饰器，@Sendable无法与其他装饰器共存
+  private removePropertyDecorators(classDecl: ClassDeclaration): void {
     classDecl.getProperties().forEach((property) => {
-      property.getDecorators().forEach((decorator) => {
-        Logger.warn(
-          `Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`
-        );
-        decorator.remove();
-      });
+      property.getDecorators().forEach((decorator) => this.logAndRemoveDecorator(decorator));
     });
+  }
 
-    // 剔除方法装饰器，@Sendable无法与其他装饰器共存
+  private removeMethodDecorators(classDecl: ClassDeclaration): void {
     classDecl.getMethods().forEach((method) => {
-      method.getDecorators().forEach((decorator) => {
-        Logger.warn(
-          `Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`
-        );
-        decorator.remove();
-      });
+      method.getDecorators().forEach((decorator) => this.logAndRemoveDecorator(decorator));
     });
   }
 
+  private logAndRemoveDecorator(decorator: Decorator): void {
+    Logger.warn(
+      `Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`
+    );
+    decorator.remove();
+  }
+
   private convertPropertyTypesToSendable(classDecl: ClassDeclaration, result: ClassAnalysis): void {
     const properties = classDecl.getProperties();
-
     properties.forEach((property) => {
-      const propertyName = property.getName();
-
-      Logger.debug(`Converting property ${propertyName} to sendable`);
-
-      // 从分析结果中找到对应的属性信息
-      const propertyAnalysis = result.properties.find((p) => p.name === propertyName);
-      if (!propertyAnalysis) {
-        Logger.warn(`未找到属性 ${propertyName} 的分析信息`);
-        return;
-      }
-
-      Logger.debug(
-        `Found property ${propertyName} analysis info: ${propertyAnalysis.name} ${propertyAnalysis.type.sourceText}`
-      );
-
-      // 转换类型为Sendable兼容类型
-      const sendableType = this.convertToSendableType(propertyAnalysis.type);
-
-      Logger.debug(`Converted type ${propertyAnalysis.type.sourceText} to ${sendableType}`);
-
-      if (sendableType !== propertyAnalysis.type.sourceText) {
-        property.setType(sendableType);
-        Logger.debug(`属性 ${propertyName} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
-      }
-
-      // 处理默认值中的构造函数调用
-      const initializer = property.getInitializer();
-      if (initializer) {
-        const initializerText = initializer.getText();
-        const convertedInitializer = this.convertInitializerToSendable(initializerText);
-        if (convertedInitializer !== initializerText) {
-          property.setInitializer(convertedInitializer);
-          Logger.debug(`属性 ${propertyName} 默认值从 ${initializerText} 转换为 ${convertedInitializer}`);
-        }
-      }
+      this.convertSinglePropertyToSendable(property, result);
     });
   }
 
+  private convertSinglePropertyToSendable(
+    property: PropertyDeclaration,
+    result: ClassAnalysis
+  ): void {
+    const propertyName = property.getName();
+    Logger.debug(`Converting property ${propertyName} to sendable`);
+
+    const propertyAnalysis = result.properties.find((p) => p.name === propertyName);
+    if (!propertyAnalysis) {
+      Logger.warn(`未找到属性 ${propertyName} 的分析信息`);
+      return;
+    }
+
+    Logger.debug(
+      `Found property ${propertyName} analysis info: ${propertyAnalysis.name} ${propertyAnalysis.type.sourceText}`
+    );
+
+    this.updatePropertyType(property, propertyAnalysis);
+    this.updatePropertyInitializer(property, propertyAnalysis.name);
+  }
+
+  private updatePropertyType(
+    property: PropertyDeclaration,
+    propertyAnalysis: PropertyAnalysis
+  ): void {
+    const sendableType = this.convertToSendableType(propertyAnalysis.type);
+    Logger.debug(`Converted type ${propertyAnalysis.type.sourceText} to ${sendableType}`);
+
+    if (sendableType !== propertyAnalysis.type.sourceText) {
+      property.setType(sendableType);
+      Logger.debug(`属性 ${propertyAnalysis.name} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
+    }
+  }
+
+  private updatePropertyInitializer(
+    property: PropertyDeclaration,
+    propertyName: string
+  ): void {
+    const initializer = property.getInitializer();
+    if (!initializer) {
+      return;
+    }
+    const initializerText = initializer.getText();
+    const convertedInitializer = this.convertInitializerToSendable(initializerText);
+    if (convertedInitializer !== initializerText) {
+      property.setInitializer(convertedInitializer);
+      Logger.debug(`属性 ${propertyName} 默认值从 ${initializerText} 转换为 ${convertedInitializer}`);
+    }
+  }
+
   private addSendableConstraints(classDecl: ClassDeclaration): void {
     // 添加@Sendable装饰器
     classDecl.addDecorator({ name: 'Sendable' });
@@ -187,7 +209,29 @@ export class SendableClassGenerator {
 
   private generatedToOriginMethodBody(result: ClassAnalysis, returnType: string): string {
     const statements: string[] = [];
-    let constructorCall;
+    const constructorCall = this.getConstructorCall(result, returnType);
+    statements.push(`const origin = ${constructorCall};`);
+
+    const assignmentProps = result.properties.filter((p) => {
+      return result.constructorParams.every((cp) => cp.name !== p.name);
+    });
+    // 生成属性赋值语句
+    if (assignmentProps.length > 0) {
+      statements.push('');
+      statements.push('// 非构造函数属性赋值');
+      assignmentProps.forEach((prop) => {
+        const assignment = this.generatePropertyConversion(prop, 'this.');
+        statements.push(`origin.${prop.name} = ${assignment};`);
+      });
+    }
+
+    statements.push('');
+    statements.push('return origin;');
+
+    return statements.join('\n');
+  }
+
+  private getConstructorCall(result: ClassAnalysis, returnType: string): string {
     if (result.constructorParams.length > 0) {
       const constructorProps: PropertyAnalysis[] = [];
       result.properties.forEach((p) => {
@@ -209,29 +253,10 @@ export class SendableClassGenerator {
         })
         .join(', ');
 
-      constructorCall = `new ${returnType}(${args})`;
+      return `new ${returnType}(${args})`;
     } else {
-      constructorCall = `new ${returnType}()`;
+      return `new ${returnType}()`;
     }
-    statements.push(`const origin = ${constructorCall};`);
-
-    const assignmentProps = result.properties.filter((p) => {
-      return result.constructorParams.every((cp) => cp.name !== p.name);
-    });
-    // 生成属性赋值语句
-    if (assignmentProps.length > 0) {
-      statements.push('');
-      statements.push('// 非构造函数属性赋值');
-      assignmentProps.forEach((prop) => {
-        const assignment = this.generatePropertyConversion(prop, 'this.');
-        statements.push(`origin.${prop.name} = ${assignment};`);
-      });
-    }
-
-    statements.push('');
-    statements.push('return origin;');
-
-    return statements.join('\n');
   }
 
   private generatePropertyConversion(prop: PropertyAnalysis, prefix: string): string {
@@ -257,84 +282,141 @@ export class SendableClassGenerator {
   }
 
   private addNecessaryImports(result: ClassAnalysis, importManager: ImportManager): void {
-    // 1. 处理类导入
+    this.processPropertyDependencyImports(result, importManager);
+    this.processBaseClassImport(result, importManager);
+    this.processCollectionsImport(result, importManager);
+    this.copySourceFileImports(result, importManager);
+  }
+
+  private processPropertyDependencyImports(result: ClassAnalysis, importManager: ImportManager): void {
     result.properties.forEach((property) => {
       property.type.dependencies.forEach((dependency) => {
-        if (dependency.typeKind === TypeKind.CLASS) {
-          const classAnalysis = ClassAnalyzer.analyzeClass((dependency.details as ClassDetails).classDecl);
-          if (classAnalysis.decorators.serializable?.generateSendable) {
-            importManager.registerCustomImport('./Sendable' + dependency.typeName, 'Sendable' + dependency.typeName);
-          } else {
-            importManager.registerCustomTypeImport(dependency.source.sourceFilePath!, dependency.typeName);
-          }
-        } else {
-          importManager.registerCustomTypeImport(dependency.source.sourceFilePath!, dependency.typeName);
-        }
+        this.registerDependencyImport(dependency, importManager);
       });
     });
+  }
+
+  private registerDependencyImport(
+    dependency: TypeDependency,
+    importManager: ImportManager
+  ): void {
+    if (dependency.typeKind !== TypeKind.CLASS) {
+      importManager.registerCustomTypeImport(dependency.source.sourceFilePath!, dependency.typeName);
+      return;
+    }
+    const classAnalysis = ClassAnalyzer.analyzeClass((dependency.details as ClassDetails).classDecl);
+    if (classAnalysis.decorators.serializable?.generateSendable) {
+      importManager.registerCustomImport('./Sendable' + dependency.typeName, 'Sendable' + dependency.typeName);
+    } else {
+      importManager.registerCustomTypeImport(dependency.source.sourceFilePath!, dependency.typeName);
+    }
+  }
 
+  private processBaseClassImport(result: ClassAnalysis, importManager: ImportManager): void {
     const baseClass = result.inheritance.baseClassAnalysis;
-    if (baseClass) {
-      importManager.registerCustomImport('./Sendable' + baseClass.className, 'Sendable' + baseClass.className);
+    if (!baseClass) {
+      return;
     }
-    // 2. 检查是否需要collections导入
+    importManager.registerCustomImport('./Sendable' + baseClass.className, 'Sendable' + baseClass.className);
+  }
+
+  private processCollectionsImport(result: ClassAnalysis, importManager: ImportManager): void {
     const needsCollections = this.needsCollectionsImport(result);
-    if (needsCollections) {
-      importManager.registerArkTSImports(['collections']);
+    if (!needsCollections) {
+      return;
     }
-    // 3. 拷贝源文件导入
-    result.originalClass?.getSourceFile().getImportDeclarations().forEach(importDecl => {
-      const specifier = importDecl.getModuleSpecifierValue();
-      const names = importDecl.getNamedImports().map((names) => names.getName());
-      const defaultImport = importDecl.getDefaultImport();
-      const originalDir = SerializationPathUtil.dirname(result.sourceFilePath);
-
-      const importOriginAbs = SerializationPathUtil.pathResolve(originalDir, specifier);
-      if (SerializationPathUtil.exist(importOriginAbs + '.ets')) {
-        // 路径存在，使用模块化路径计算
-        const importOriginAbsWithExt = importOriginAbs + '.ets';
-        names.forEach((name) => {
-          importManager.registerCustomTypeImport(importOriginAbsWithExt, name);
-        });
-        if (defaultImport) {
-          importManager.registerDefaultImport(importOriginAbsWithExt, defaultImport.getText());
-        }
-      } else {
-        // 不存在该路径，说明可能为包名，暂时不动
-        names.forEach((name) => {
-          importManager.registerCustomImport(specifier, name);
-        });
-        if (defaultImport) {
-          importManager.registerDefaultImport(specifier, defaultImport.getText());
-        }
-      }
+    importManager.registerArkTSImports(['collections']);
+  }
+
+  private copySourceFileImports(result: ClassAnalysis, importManager: ImportManager): void {
+    const importDeclarations = result.originalClass?.getSourceFile().getImportDeclarations();
+    if (!importDeclarations) {
+      return;
+    }
+    importDeclarations.forEach((importDecl) => {
+      this.processSingleImportDeclaration(importDecl, result, importManager);
+    });
+  }
+
+  private processSingleImportDeclaration(
+    importDecl: ImportDeclaration,
+    result: ClassAnalysis,
+    importManager: ImportManager
+  ): void {
+    const specifier = importDecl.getModuleSpecifierValue();
+    const names = importDecl.getNamedImports().map((n) => n.getName());
+    const defaultImport = importDecl.getDefaultImport();
+    const originalDir = SerializationPathUtil.dirname(result.sourceFilePath);
+    const importOriginAbs = SerializationPathUtil.pathResolve(originalDir, specifier);
+
+    if (SerializationPathUtil.exist(importOriginAbs + '.ets')) {
+      this.registerModuleImports(importOriginAbs + '.ets', names, defaultImport, importManager);
+    } else {
+      this.registerPackageImports(specifier, names, defaultImport, importManager);
+    }
+  }
+
+  private registerModuleImports(
+    absPath: string,
+    names: string[],
+    defaultImport: Identifier | undefined,
+    importManager: ImportManager
+  ): void {
+    names.forEach((name) => {
+      importManager.registerCustomTypeImport(absPath, name);
+    });
+    if (defaultImport) {
+      importManager.registerDefaultImport(absPath, defaultImport.getText());
+    }
+  }
+
+  private registerPackageImports(
+    specifier: string,
+    names: string[],
+    defaultImport: Identifier | undefined,
+    importManager: ImportManager
+  ): void {
+    names.forEach((name) => {
+      importManager.registerCustomImport(specifier, name);
     });
+    if (defaultImport) {
+      importManager.registerDefaultImport(specifier, defaultImport.getText());
+    }
   }
 
   private convertConstructorParameterTypes(classDecl: ClassDeclaration, result: ClassAnalysis): void {
     const constructors = classDecl.getConstructors();
-
     constructors.forEach((constructor) => {
-      const parameters = constructor.getParameters();
+      this.convertSingleConstructorParameters(constructor, result);
+    });
+  }
 
-      parameters.forEach((parameter) => {
-        const paramName = parameter.getName();
+  private convertSingleConstructorParameters(
+    constructor: ConstructorDeclaration,
+    result: ClassAnalysis
+  ): void {
+    const parameters = constructor.getParameters();
+    parameters.forEach((parameter) => {
+      this.convertSingleParameter(parameter, result);
+    });
+  }
 
-        // 从分析结果中找到对应的属性信息
-        const propertyAnalysis = result.properties.find((p) => p.name === paramName);
-        if (!propertyAnalysis) {
-          Logger.warn(`未找到构造函数参数 ${paramName} 的分析信息`);
-          return;
-        }
+  private convertSingleParameter(
+    parameter: ParameterDeclaration,
+    result: ClassAnalysis
+  ): void {
+    const paramName = parameter.getName();
+    const propertyAnalysis = result.properties.find((p) => p.name === paramName);
+    if (!propertyAnalysis) {
+      Logger.warn(`未找到构造函数参数 ${paramName} 的分析信息`);
+      return;
+    }
 
-        // 转换参数类型为Sendable兼容类型
-        const sendableType = this.convertToSendableType(propertyAnalysis.type);
-        if (sendableType !== propertyAnalysis.type.sourceText) {
-          parameter.setType(sendableType);
-          Logger.debug(`构造函数参数 ${paramName} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
-        }
-      });
-    });
+    const sendableType = this.convertToSendableType(propertyAnalysis.type);
+    if (sendableType !== propertyAnalysis.type.sourceText) {
+      parameter.setType(sendableType);
+      Logger.debug(`构造函数参数 ${paramName} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
+    }
   }
 
   private isObjectType(typeName: string): boolean {
@@ -371,41 +453,50 @@ export class SendableClassGenerator {
   }
 
   private convertInitializerToSendable(initializerText: string): string {
-    let convertedText = initializerText;
-
-    // 1. 处理数组字面量（最优先）
-    if (convertedText === '[]') {
-      convertedText = 'new collections.Array()';
-    } else if (convertedText.startsWith('[') && convertedText.endsWith(']')) {
-      // 处理 [1, 2, 3] 这种情况
-      const arrayContent = convertedText.slice(1, -1);
-      if (arrayContent.trim()) {
-        convertedText = `new collections.Array(${arrayContent})`;
-      } else {
-        convertedText = 'new collections.Array()';
-      }
-    }
+    let convertedText = this.convertArrayLiteralToSendable(initializerText);
+    convertedText = this.replaceCollectionTypes(convertedText);
+    convertedText = this.replaceObjectConstructors(convertedText);
 
-    // 2. 处理集合类型构造函数（优先于对象类型）
-    convertedText = convertedText.replace(/new\s+Set\s*\(/g, 'new collections.Set(');
-    convertedText = convertedText.replace(/new\s+Map\s*\(/g, 'new collections.Map(');
-    convertedText = convertedText.replace(/new\s+Array\s*\(/g, 'new collections.Array(');
+    Logger.debug(`初始化器转换: ${initializerText} -> ${convertedText}`);
+    return convertedText;
+  }
 
-    // 3. 处理对象构造函数：new Person(...) -> new SendablePerson(...)
+  private convertArrayLiteralToSendable(text: string): string {
+    if (text === '[]') {
+      return 'new collections.Array()';
+    }
+    if (!text.startsWith('[') || !text.endsWith(']')) {
+      return text;
+    }
+    const arrayContent = text.slice(1, -1);
+    if (arrayContent.trim()) {
+      return `new collections.Array(${arrayContent})`;
+    }
+    return 'new collections.Array()';
+  }
+
+  private replaceObjectConstructors(text: string): string {
     const objectConstructorPattern = /new\s+(\w+)\s*\(/g;
-    convertedText = convertedText.replace(objectConstructorPattern, (match, className) => {
-      // 跳过已经转换的集合类型
-      if (className === 'collections' || match.includes('collections.')) {
-        return match;
-      }
-
-      if (this.isObjectType(className)) {
-        return match.replace(className, `Sendable${className}`);
-      }
-      return match;
+    return text.replace(objectConstructorPattern, (match, className) => {
+      return this.replaceObjectConstructorMatch(match, className);
     });
+  }
 
-    Logger.debug(`初始化器转换: ${initializerText} -> ${convertedText}`);
+  private replaceObjectConstructorMatch(match: string, className: string): string {
+    if (className === 'collections' || match.includes('collections.')) {
+      return match;
+    }
+    if (this.isObjectType(className)) {
+      return match.replace(className, `Sendable${className}`);
+    }
+    return match;
+  }
+
+  private replaceCollectionTypes(text: string): string {
+    let convertedText = text;
+    convertedText = convertedText.replace(/new\s+Set\s*\(/g, 'new collections.Set(');
+    convertedText = convertedText.replace(/new\s+Map\s*\(/g, 'new collections.Map(');
+    convertedText = convertedText.replace(/new\s+Array\s*\(/g, 'new collections.Array(');
     return convertedText;
   }
 

package/src/core/services/CodeGenerationService/generators/SerializerGenerator.ts

@@ -106,7 +106,7 @@ export class SerializerGenerator {
     this.importManager.registerCoreImports([
       'Serializer', 'SerialDescriptor', 'buildClassSerialDescriptor',
       'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'ObjectUtils',
-      'registerAutoGeneratedSerializerEntryProviderForSupplementary',
+      'registerAutoGeneratedSerializerEntryProviderForSupplementary', 'lazy',
       ...requiredBuiltinSerializers
     ]);
 

package/src/core/services/CodeGenerationService/generators/TempSerializerGenerator.ts

@@ -38,7 +38,8 @@ export class TempSerializerGenerator {
   private context: ITaskContext | null = null;
   private serializerFiles: Map<string, SerializerFileInfo> = new Map();
 
-  private constructor() { }
+  private constructor() {
+  }
 
   static getInstance(): TempSerializerGenerator {
     return this.INSTANCE;
@@ -102,7 +103,7 @@ export class TempSerializerGenerator {
     });
   }
 
-  private registerImports(classAnalysis: ClassAnalysis | InterfaceAnalysis, importManager: ImportManager) {
+  private registerImports(classAnalysis: ClassAnalysis | InterfaceAnalysis, importManager: ImportManager): void {
     // 注册源文件导入
     importManager.registerCustomTypeImport(classAnalysis.sourceFilePath, classAnalysis.className);
     // 拷贝源文件导入
@@ -174,7 +175,8 @@ export class TempSerializerGenerator {
     // 检测类名冲突
     const classNameMap = new Map<string, SerializerFileInfo[]>();
     for (const [_, fileInfo] of this.serializerFiles) {
-      const serializerName = `${fileInfo.className}${fileInfo.isGeneric ? StringConstants.SERIALIZER_FACTORY : StringConstants.SERIALIZER}`;
+      const serializerName = `${fileInfo.className}${fileInfo.isGeneric ? StringConstants.SERIALIZER_FACTORY :
+        StringConstants.SERIALIZER}`;
       if (!classNameMap.has(serializerName)) {
         classNameMap.set(serializerName, []);
       }

package/src/core/services/CodeGenerationService/shared/ImportManager.ts

@@ -47,7 +47,7 @@ export class ImportManager {
     }
   }
 
-  registerArkTSImports(names: string[]) {
+  registerArkTSImports(names: string[]): void {
     const arkTSModule = '@kit.ArkTS';
 
     for (const name of names) {
@@ -59,7 +59,7 @@ export class ImportManager {
     // 智能去重：检查是否已有同名类型的更好路径
     if (this.typeToModulePath.has(importedName)) {
       const existingModulePath = this.typeToModulePath.get(importedName)!;
-      
+
       // 如果当前路径是模块化路径，而已存在的是相对路径，则替换
       if (this.isModularPath(modulePath) && this.isRelativePath(existingModulePath)) {
         // 移除旧的相对路径导入
@@ -106,10 +106,10 @@ export class ImportManager {
    * 判断是否为模块化路径（不以 . 或 / 开头，不是 @开头的包名）
    */
   private isModularPath(modulePath: string): boolean {
-    return !modulePath.startsWith('.') && 
-           !modulePath.startsWith('/') && 
-           !modulePath.startsWith('@') &&
-           modulePath.includes('/');
+    return !modulePath.startsWith('.') &&
+      !modulePath.startsWith('/') &&
+      !modulePath.startsWith('@') &&
+      modulePath.includes('/');
   }
 
   private isRelativePath(modulePath: string): boolean {
@@ -120,7 +120,7 @@ export class ImportManager {
     if (this.imports.has(modulePath)) {
       const existingInfo = this.imports.get(modulePath)!;
       const filteredNames = existingInfo.importedNames.filter(name => name !== importedName);
-      
+
       if (filteredNames.length === 0) {
         // 如果该模块没有其他导入，则删除整个模块
         this.imports.delete(modulePath);
@@ -134,7 +134,7 @@ export class ImportManager {
     }
   }
 
-  getImportDeclarations() {
+  getImportDeclarations(): Array<{ specifier: string, names: string[] }> {
     const imports: Array<{ specifier: string, names: string[] }> = [];
     for (const [specifier, infos] of this.imports) {
       imports.push({ specifier: specifier, names: infos.importedNames });