@hadss/turbo-trans-json-plugin 1.0.0-rc.0

package/src/core/utils/DeepCopyUtil.ts

@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  PropertyAnalysis, TypeStructure, TypeDependency, PropertyDecorators, DependencySource,
+  TypeDetails, EnumDetails, EnumMemberInfo, ClassDetails, InterfaceDetails, TypeAliasDetails
+} from '..';
+
+export class DeepCopyUtil {
+  static copyPropertyAnalysis(original: PropertyAnalysis): PropertyAnalysis {
+    return {
+      name: original.name,
+      defaultValue: original.defaultValue,
+      decorators: this.copyPropertyDecorators(original.decorators),
+      isMust: original.isMust,
+      type: this.copyTypeStructure(original.type)
+    };
+  }
+
+  private static copyPropertyDecorators(original?: PropertyDecorators): PropertyDecorators | undefined {
+    if (!original) {
+      return undefined;
+    }
+    return {
+      serialName: original.serialName,
+      isRequired: original.isRequired,
+      isTransient: original.isTransient,
+      with: original.with
+    };
+  }
+
+  static copyTypeStructure(original: TypeStructure): TypeStructure {
+    const copy: TypeStructure = {
+      kind: original.kind,
+      depth: original.depth,
+      sourceText: original.sourceText,
+      args: [], // 初始化为空数组，后面会根据原始值拷贝
+      dependencies: this.copyTypeDependencies(original.dependencies)
+    };
+
+    // 深拷贝枚举详细信息
+    if (original.enumDetails) {
+      copy.enumDetails = this.copyEnumDetails(original.enumDetails);
+    }
+
+    // 深拷贝类详细信息
+    if (original.classDetails) {
+      copy.classDetails = this.copyClassDetails(original.classDetails);
+    }
+
+    if (original.unionDetails) {
+      copy.unionDetails = original.unionDetails.map(
+        member => this.copyTypeStructure(member)
+      );
+    }
+
+    if (original.args && original.args.length > 0) {
+      copy.args = original.args.map(
+        arg => this.copyTypeStructure(arg)
+      );
+    }
+
+    return copy;
+  }
+
+  static copyTypeDependencies(original: TypeDependency[]): TypeDependency[] {
+    return original.map(dependency => this.copyTypeDependency(dependency));
+  }
+
+  private static copyTypeDependency(original: TypeDependency): TypeDependency {
+    const copy: TypeDependency = {
+      typeName: original.typeName,
+      typeKind: original.typeKind,
+      importPath: original.importPath,
+      source: this.copyDependencySource(original.source)
+    };
+
+    // 深拷贝详细信息（如果存在）
+    if (original.details) {
+      copy.details = this.copyTypeDetails(original.details);
+    }
+
+    return copy;
+  }
+
+  private static copyDependencySource(original: DependencySource): DependencySource {
+    return {
+      type: original.type,
+      sourceFilePath: original.sourceFilePath,
+      originalImport: original.originalImport,
+      packageName: original.packageName
+    };
+  }
+
+  private static copyTypeDetails(original: TypeDetails): TypeDetails {
+    // TypeDetails 是联合类型，需要根据 kind 分别处理
+    switch (original.kind) {
+      case 'enum':
+        return this.copyEnumDetails(original);
+      case 'class':
+        return this.copyClassDetails(original);
+      case 'interface':
+        return this.copyInterfaceDetails(original);
+      case 'type':
+        return this.copyTypeAliasDetails(original);
+      default:
+        // 默认浅拷贝未知类型
+        return { ...original };
+    }
+  }
+
+  private static copyEnumDetails(original: EnumDetails): EnumDetails {
+    return {
+      kind: original.kind,
+      members: original.members ? original.members.map((member: EnumMemberInfo) => ({
+        name: member.name,
+        value: member.value,
+        literalValue: member.literalValue
+      })) : [],
+      valueType: original.valueType
+    };
+  }
+
+  private static copyClassDetails(original: ClassDetails): ClassDetails {
+    return {
+      kind: original.kind,
+      classDecl: original.classDecl,
+      isGeneric: original.isGeneric
+    };
+  }
+
+  private static copyInterfaceDetails(original: InterfaceDetails): InterfaceDetails {
+    return {
+      kind: original.kind,
+      interfaceDecl: original.interfaceDecl,
+      isGeneric: original.isGeneric
+    };
+  }
+
+  private static copyTypeAliasDetails(original: TypeAliasDetails): TypeAliasDetails {
+    return {
+      kind: original.kind,
+      aliasedType: original.aliasedType,
+      resolvedType: this.copyTypeStructure(original.resolvedType!)
+    };
+  }
+
+  static deepCopy<T>(obj: T): T {
+    if (obj === null || typeof obj !== 'object') {
+      return obj;
+    }
+
+    if (obj instanceof Date) {
+      return new Date(obj.getTime()) as unknown as T;
+    }
+
+    if (obj instanceof Array) {
+      return obj.map(item => this.deepCopy(item)) as unknown as T;
+    }
+
+    if (typeof obj === 'object') {
+      const copy: any = {};
+      for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          copy[key] = this.deepCopy((obj as any)[key]);
+        }
+      }
+      return copy as T;
+    }
+
+    return obj;
+  }
+}

package/src/core/utils/GenericTypeSubstitutionUtil.ts

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TypeNode } from 'ts-morph';
+import { PropertyAnalysis, TypeStructure, PropertyKind, TypeDependency } from '..';
+import { TypeHandlerRegistry } from '../handlers';
+import { DeepCopyUtil } from './DeepCopyUtil';
+
+export class GenericTypeSubstitutionUtil {
+  /**
+   * 构建泛型参数映射表
+   * @param parentGenericParams 父类泛型参数定义 ["T", "U"]
+   * @param childTypeArguments 子类传入的具体类型 ["string", "number"]
+   * @returns 映射表 Map { "T" => "string", "U" => "number" }
+   */
+  static buildGenericMapping(parentGenericParams: string[], childTypeArguments: TypeNode[]): Map<string, TypeNode> {
+    const mapping = new Map<string, TypeNode>();
+
+    const length = Math.min(parentGenericParams.length, childTypeArguments.length);
+
+    for (let i = 0; i < length; i++) {
+      mapping.set(parentGenericParams[i], childTypeArguments[i]);
+    }
+
+    return mapping;
+  }
+
+  /**
+   * 对属性类型进行泛型替换
+   * @param property 原始属性分析
+   * @param genericMapping 泛型参数映射 { "T": "string", "U": "number" }
+   * @param currentClassGenericParams 当前类的泛型参数列表
+   * @returns 替换后的属性分析
+   */
+  static substitutePropertyType(
+    property: PropertyAnalysis,
+    genericMapping: Map<string, TypeNode>,
+    currentClassGenericParams: string[] = []
+  ): PropertyAnalysis {
+    if (genericMapping.size === 0) {
+      return property; // 没有泛型替换，直接返回
+    }
+
+    // 使用深拷贝避免引用问题
+    const newProperty: PropertyAnalysis = DeepCopyUtil.copyPropertyAnalysis(property);
+
+    // 递归替换类型结构中的泛型参数
+    newProperty.type = this.substituteTypeStructure(newProperty.type, genericMapping, currentClassGenericParams);
+
+    return newProperty;
+  }
+
+  private static substituteTypeStructure(
+    typeStructure: TypeStructure,
+    mapping: Map<string, TypeNode>,
+    currentClassGenericParams: string[] = []
+  ): TypeStructure {
+    // 1. 处理泛型类型替换（核心逻辑）
+    if (typeStructure.kind === PropertyKind.GENERIC) {
+      // 对于泛型类型，sourceText 就是泛型参数名（如 "T", "U", "TData"）
+      const genericTypeName = typeStructure.sourceText;
+      if (mapping.has(genericTypeName)) {
+        const substitutedTypeNode = mapping.get(genericTypeName)!;
+
+        return this.constructTypeStructureFromTypeName(substitutedTypeNode, currentClassGenericParams);
+      }
+      // 如果没有找到对应的映射，保持原样
+      return typeStructure;
+    }
+
+    // 2. 递归处理非泛型类型的子结构
+    // 使用深拷贝避免修改原始对象
+    const newStructure: TypeStructure = DeepCopyUtil.copyTypeStructure(typeStructure);
+
+    // 递归替换所有子结构中的泛型类型
+    if (newStructure.unionDetails) {
+      newStructure.unionDetails = newStructure.unionDetails.map(
+        member => this.substituteTypeStructure(member, mapping, currentClassGenericParams)
+      );
+    }
+
+    if (newStructure.args) {
+      newStructure.args = newStructure.args.map(
+        arg => this.substituteTypeStructure(arg, mapping, currentClassGenericParams)
+      );
+    }
+
+    // 重新计算依赖信息
+    newStructure.dependencies = this.collectDependenciesFromChildren(newStructure);
+
+    return newStructure;
+  }
+
+  private static constructTypeStructureFromTypeName(
+    typeNode: TypeNode,
+    currentClassGenericParams: string[] = []
+  ): TypeStructure {
+    return TypeHandlerRegistry.getInstance().parseType(typeNode, {
+      depth: 0,
+      genericParams: currentClassGenericParams // ✅ 传递当前类的泛型参数上下文
+    })
+  }
+
+  private static collectDependenciesFromChildren(children: TypeStructure): TypeDependency[] {
+    const allDependencies: TypeDependency[] = [];
+
+    if (children.unionDetails) {
+      for (const member of children.unionDetails) {
+        if (member.dependencies) {
+          allDependencies.push(...member.dependencies);
+        }
+      }
+    }
+    if (children.args) {
+      for (const arg of children.args) {
+        if (arg.dependencies) {
+          allDependencies.push(...arg.dependencies);
+        }
+      }
+    }
+
+    return allDependencies;
+  }
+}

package/src/core/utils/SerializationPathUtil.ts

@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { FileUtil } from '@ohos/hvigor';
+import * as path from "path";
+import * as fs from "fs";
+import { ITaskContext, PathConstants } from '..';
+
+export default class SerializationPathUtil extends FileUtil {
+  static readonly sep: string = path.sep;
+
+  static dirname(p: string): string {
+    return path.dirname(p);
+  }
+
+  static basename(p: string, suffix?: string): string {
+    return path.basename(p, suffix);
+  }
+
+  static extname(p: string): string {
+    return path.extname(p);
+  }
+
+  static isAbsolute(p: string): boolean {
+    return path.isAbsolute(p)
+  }
+
+  static normalize(p: string): string {
+    return path.normalize(p)
+  }
+
+  static relative(from: string, to: string): string {
+    return path.relative(from, to);
+  }
+
+  static join(...paths: string[]): string {
+    return path.join(...paths);
+  }
+
+  static rmSync(path: fs.PathLike, options?: fs.RmOptions,): void {
+    return fs.rmSync(path, options);
+  }
+
+  /**
+   * 计算模块化导入路径
+   * 将绝对文件路径转换为模块化导入路径
+   *
+   * @param absolutePath 绝对文件路径，例如: /project/sampleentry/src/generated/ets/model/Person.ets
+   * @param context 任务上下文，提供模块名称和路径上下文
+   * @returns 模块化导入路径，例如: sampleentry/ets/model/Person
+   */
+  static calculateModularImportPath(absolutePath: string, context: ITaskContext): string {
+    const packageName = context.getPackageName();
+
+    const moduleRelativePath = context.calculateSourceRootToModuleRoot(absolutePath);
+
+    // 移除文件扩展名
+    const pathWithoutExtension = this.removeFileExtension(moduleRelativePath);
+
+    // 拼接模块化路径
+    return `${packageName}/${pathWithoutExtension}`;
+  }
+
+  /**
+   * 计算Sendable类的输出路径
+   * 将原始源文件路径映射到sendableModel目录
+   *
+   * @param className 原始类名
+   * @param context 任务上下文
+   * @returns Sendable类的输出路径
+   */
+  static mapToSendableOutputPath(className: string, context: ITaskContext): string {
+    // 获取基础输出路径（不包含文件名）
+    const baseOutputDir = context.getOutputRoot();
+
+    // 构建sendableModel目录路径
+    const sendableModelDir = this.join(baseOutputDir, 'ets/sendableModel');
+
+    // 返回完整的Sendable类文件路径
+    return this.join(sendableModelDir, `Sendable${className}.ets`);
+  }
+
+  /**
+   * 递归扫描目录，获取所有 ETS 文件
+   *
+   * @param directory 要扫描的目录路径
+   * @returns 所有 ETS 文件的绝对路径数组
+   */
+  static scanEtsFiles(directory: string): string[] {
+    const etsFiles: string[] = [];
+
+    const deepScanEtsFiles = (scanPath: string, relativePath: string) => {
+      let resolvePath = this.pathResolve(scanPath, relativePath);
+
+      if (!this.exist(resolvePath)) {
+        return;
+      }
+
+      if (this.isDictionary(resolvePath)) {
+        const files: string[] = fs.readdirSync(resolvePath);
+        files.forEach(file => {
+          deepScanEtsFiles(resolvePath, file);
+        });
+      } else {
+        // 只收集 .ets 文件
+        if (path.extname(relativePath) === PathConstants.ETS_EXTENSIONS) {
+          etsFiles.push(resolvePath);
+        }
+      }
+    }
+
+    deepScanEtsFiles(directory, '');
+
+    return etsFiles;
+  }
+
+  /**
+   * 移除文件扩展名
+   *
+   * @param filePath 文件路径
+   * @returns 无扩展名的路径
+   */
+  private static removeFileExtension(filePath: string): string {
+    const lastDotIndex = filePath.lastIndexOf('.');
+    if (lastDotIndex > 0) {
+      return filePath.substring(0, lastDotIndex);
+    }
+    return filePath;
+  }
+}

package/src/core/utils/TsMorphUtil.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Project, ProjectOptions, TypeChecker } from 'ts-morph';
+import { Logger } from '../logger/Logger';
+
+export class TsMorphUtil {
+  public static project: Project | null = null;
+  private constructor() { }
+  public static getProject(options?: ProjectOptions): Project {
+    if (!this.project) {
+      Logger.info('创建ts-morph项目');
+      this.project = new Project(
+        options || {
+          compilerOptions: {
+            allowNonTsExtensions: true
+          }
+        }
+      );
+    }
+    return this.project;
+  }
+
+  public static getTypeChecker(): TypeChecker {
+    return this.getProject().getTypeChecker();
+  }
+
+  public static clearProject(): void {
+    const sourceFiles = TsMorphUtil.getProject().getSourceFiles();
+    Logger.info(`Clearing ${sourceFiles.length} source files...`);
+    if (sourceFiles && sourceFiles.length > 0) {
+      sourceFiles.forEach((sourceFile) => {
+        TsMorphUtil.getProject().removeSourceFile(sourceFile);
+      });
+    }
+    TsMorphUtil.project = null;
+  }
+}

package/src/index.ts

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { HvigorNode, HvigorPlugin } from '@ohos/hvigor';
+import { Hvigor } from '@ohos/hvigor/src/base/external/core/hvigor';
+import { DeserializationMode, PathConstants, TurboTransJsonPluginOptions, StringConstants } from './core';
+import { initializeTypeHandlers } from './core/handlers/HandlerBootstrap';
+import { JSONExecuteController } from './json-plugin/JSONExecuteController';
+
+const PLUGIN_ID = StringConstants.PLUGIN_ID;
+const DEFAULT_OPTIONS: TurboTransJsonPluginOptions = {
+  ignoreModuleNames: [],
+  scanDir: PathConstants.DEFAULT_SCAN_DIRS,
+  deserializationMode: DeserializationMode.PERFORMANCE,
+};
+
+export function turboTransJsonPlugin(hvigor: Hvigor,
+  options: TurboTransJsonPluginOptions = DEFAULT_OPTIONS): HvigorPlugin {
+  return {
+    pluginId: PLUGIN_ID,
+    apply(node: HvigorNode): void {
+      TurboTransJSONPluginManager.getInstance(hvigor).initialization(node, options);
+    }
+  };
+}
+
+class TurboTransJSONPluginManager {
+  private static instance: TurboTransJSONPluginManager | null;
+  private moduleExecuteControllers: Set<JSONExecuteController> = new Set(); // 每个模块对应的JSON插件
+
+  private constructor(hvigor: Hvigor) {
+    this.setupHvigorHooks(hvigor);
+  }
+
+  static getInstance(hvigor: Hvigor): TurboTransJSONPluginManager {
+    if (!TurboTransJSONPluginManager.instance) {
+      TurboTransJSONPluginManager.instance = new TurboTransJSONPluginManager(hvigor);
+    }
+    return TurboTransJSONPluginManager.instance;
+  }
+
+  initialization(node: HvigorNode, options: TurboTransJsonPluginOptions) {
+    initializeTypeHandlers();
+    node.subNodes(subNode => {
+      const subNodeName = subNode.getNodeName();
+      if (options.ignoreModuleNames.includes(subNodeName)) {
+        return;
+      }
+      const executeController = new JSONExecuteController(subNode, options);
+      this.moduleExecuteControllers.add(executeController);
+    });
+  }
+
+  private setupHvigorHooks(hvigor: Hvigor) {
+    hvigor.nodesEvaluated(() => {
+      this.moduleExecuteControllers.forEach(controller => {
+        controller.execute();
+      });
+    });
+
+    hvigor.buildFinished(() => {
+      this.moduleExecuteControllers.forEach(controller => {
+        controller.compile();
+      });
+      this.moduleExecuteControllers.clear();
+      TurboTransJSONPluginManager.instance = null;
+    });
+  }
+}