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

package/src/core/constants/StringConstants.ts

@@ -0,0 +1,152 @@
+/*
+ * 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 { PropertyKind } from '../Types';
+
+/**
+ * 字符串常量统一管理
+ * 避免硬编码字符串散布在代码中
+ */
+export class StringConstants {
+  
+  // ========== 基础类型字符串 ==========
+  static readonly TYPE_BOOLEAN = 'boolean'
+  static readonly TYPE_NUMBER = 'number'
+  static readonly TYPE_STRING = 'string'
+  static readonly TYPE_BIGINT = 'bigint'
+  static readonly TYPE_NULL = 'null'
+  static readonly TYPE_UNDEFINED = 'undefined'
+  static readonly TYPE_ARRAY = 'array'
+  static readonly TYPE_SET = 'set'
+  static readonly TYPE_MAP = 'map'
+  static readonly TYPE_UNION = 'union'
+  static readonly TYPE_ENUM = 'enum'
+
+  // ========== 序列化器名称 ==========
+  // 基础类型序列化器（单例INSTANCE模式）
+  static readonly BOOLEAN_SERIALIZER = 'BooleanSerializer'
+  static readonly NUMBER_SERIALIZER = 'NumberSerializer'
+  static readonly STRING_SERIALIZER = 'StringSerializer'
+  static readonly BIGINT_SERIALIZER = 'BigintSerializer'
+  
+  // 特殊原始类型序列化器（单例INSTANCE模式）
+  static readonly NULL_SERIALIZER = 'NullSerializer'
+  static readonly UNDEFINED_SERIALIZER = 'UndefinedSerializer'
+  
+  // 集合类型序列化器（泛型构造器模式）
+  static readonly ARRAY_SERIALIZER = 'ArraySerializer'
+  static readonly COLLECTIONS_ARRAY_SERIALIZER = 'CollectionsArraySerializer'
+  static readonly MAP_SERIALIZER = 'MapSerializer'
+  static readonly COLLECTIONS_MAP_SERIALIZER = 'CollectionsMapSerializer'
+  static readonly SET_SERIALIZER = 'SetSerializer'
+  static readonly COLLECTIONS_SET_SERIALIZER = 'CollectionsSetSerializer'
+  static readonly RECORD_SERIALIZER = 'RecordSerializer'
+
+  // 高级类型序列化器（特殊构造器模式）
+  static readonly UNION_TYPE_SERIALIZER = 'UnionTypeSerializer'
+  static readonly OPTIONAL_SERIALIZER = 'OptionalSerializer'
+  static readonly NULLABLE_SERIALIZER = 'NullableSerializer'
+  static readonly ENUM_SERIALIZER = 'EnumSerializer'
+  
+  // 通用序列化器
+  static readonly SERIALIZER = 'Serializer'
+  static readonly SERIALIZER_FACTORY = 'SerializerFactory'
+
+  // ========== 编码/解码方法名 ==========
+  // 基础类型专用编码方法
+  static readonly ENCODE_BOOLEAN_ELEMENT = 'encodeBooleanElement'
+  static readonly ENCODE_NUMBER_ELEMENT = 'encodeNumberElement'
+  static readonly ENCODE_STRING_ELEMENT = 'encodeStringElement'
+  static readonly ENCODE_BIGINT_ELEMENT = 'encodeBigintElement'
+  
+  // 特殊原始类型专用编码方法
+  static readonly ENCODE_NULL_ELEMENT = 'encodeNullElement'
+  static readonly ENCODE_UNDEFINED_ELEMENT = 'encodeUndefinedElement'
+  
+  // 通用编码方法
+  static readonly ENCODE_SERIALIZABLE_ELEMENT = 'encodeSerializableElement'
+
+  // 基础类型专用解码方法
+  static readonly DECODE_BOOLEAN = 'decodeBoolean'
+  static readonly DECODE_NUMBER = 'decodeNumber'
+  static readonly DECODE_STRING = 'decodeString'
+  static readonly DECODE_BIGINT = 'decodeBigint'
+  
+  // 特殊原始类型专用解码方法
+  static readonly DECODE_NULL = 'decodeNull'
+  static readonly DECODE_UNDEFINED = 'decodeUndefined'
+  
+  // 通用解码方法
+  static readonly DESERIALIZABLE = 'deserialize'
+
+  // ========== 导入模块相关 ==========
+  static readonly IMPORT_BUILD_CLASS_SERIAL_DESCRIPTOR = 'buildClassSerialDescriptor'
+  static readonly IMPORT_DECODER = 'Decoder'
+  static readonly IMPORT_ENCODER = 'Encoder'
+  static readonly IMPORT_SERIAL_DESCRIPTOR = 'SerialDescriptor'
+  static readonly IMPORT_SERIALIZER = 'Serializer'
+
+  static readonly IMPORT_TJSON = 'TJSON'
+  static readonly IMPORT_IT_SERIALIZABLE = 'ITSerializable'
+  static readonly IMPORT_LANG = 'lang'
+
+  // ========== 类型推断相关 ==========
+  static readonly BOOLEAN_WRAPPER = 'Boolean'
+  static readonly NUMBER_WRAPPER = 'Number'
+  static readonly STRING_WRAPPER = 'String'
+
+  static readonly ARRAY_SUFFIX = '[]'
+  static readonly ARRAY_PREFIX = 'array<'
+
+  // ========== 默认值相关 ==========
+  static readonly DEFAULT_VALUE_FALSE = 'false'
+  static readonly DEFAULT_VALUE_ZERO = '0'
+  static readonly DEFAULT_VALUE_EMPTY_STRING = "''"
+  static readonly DEFAULT_VALUE_ZERO_BIGINT = '0n'
+  static readonly DEFAULT_VALUE_UNDEFINED = 'undefined'
+
+  // ========== 模板字符串片段 ==========
+  static readonly TEMPLATE_ELEMENT_NAME = 'element'
+  static readonly TEMPLATE_SENDABLE_ERROR_PREFIX = 'Sendable support not enabled for'
+  
+  // ========== 文件操作相关 ==========
+  static readonly FILE_OPERATION_EMPTY_STRING = ''
+  static readonly REGEX_IMPORT_STATEMENT = /import\s+({[^}]+}|\w+)\s+from\s+'([^']+)'/
+  static readonly REGEX_SRC_MAIN_ETS = /\/src\/main\/ets\/(.*)\.ets$/
+  
+  // ========== 分隔符和连接符 ==========
+  static readonly SEPARATOR_COMMA = ','
+  static readonly SEPARATOR_COMMA_NEWLINE = ',\n'
+  static readonly SEPARATOR_NEWLINE = '\n'
+  static readonly SEPARATOR_COMMA_SPACE = ', '
+  static readonly JOIN_ELEMENT_PREFIX = ',\n  '
+  
+  // ========== 正则表达式字符串 ==========
+  static readonly CURLY_BRACE_START = '{'
+  static readonly PATH_RELATIVE_PREFIX = './'
+  static readonly INSTANCE_SUFFIX = '.INSTANCE'
+  static readonly SERIALIZER_SUFFIX = 'Serializer'
+  
+  // ========== 日志前缀 ==========
+  static readonly LOG_PREFIX_T_SERIALIZATION = '[TSerialization]'
+  static readonly LOG_MODULE_PREFIX_TEMPLATE = '[${module}]'
+  
+  // ========== 插件标识 ==========
+  static readonly PLUGIN_ID = 'turboTransJsonPlugin'
+  
+  // ========== 模块标识符 ==========
+  static readonly JSON_MODULE_SPECIFIER = '@hadss/hmserialization-json'
+  static readonly ARKTS_MODULE_SPECIFIER = '@kit.ArkTS'
+}

package/src/core/constants/index.ts

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+/**
+ * Core常量统一导出
+ */
+export * from './StringConstants';
+export * from './DecoratorConstants';
+export * from './PathConstants';

package/src/core/handlers/BaseTypeHandler.ts

@@ -0,0 +1,121 @@
+/*
+ * 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 { ITypeHandler, TypeContext, ConversionDirection } from './ITypeHandler';
+import { PropertyKind, SerializerMetadata, TypeStructure } from '../Types';
+
+export abstract class BaseTypeHandler implements ITypeHandler {
+  abstract readonly name: string;
+  abstract readonly kind: PropertyKind;
+  abstract readonly priority: number;
+
+  // 子类必须实现的所有核心方法
+  abstract matches(typeNode: TypeNode, context: TypeContext): boolean;
+  abstract parse(typeNode: TypeNode, context: TypeContext): TypeStructure;
+  abstract getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata;
+  abstract generateInstantiation(structure: TypeStructure): string;
+  abstract generateTypeDeclaration(structure: TypeStructure): string;
+  abstract generateTypeKey(structure: TypeStructure): string;
+  abstract generateSendableTypeDeclaration(structure: TypeStructure): string;
+  abstract generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string;
+
+  /** 获取序列化器名称（约定：TypeName + Serializer）*/
+  protected getSerializerName(): string {
+    return `${this.getTypeName()}Serializer`;
+  }
+
+  /** 获取类型名称 */
+  protected getTypeName(): string {
+    return this.capitalize(this.kind);
+  }
+
+  /** 首字母大写 */
+  protected capitalize(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  // ==================== With参数处理 ====================
+
+  /**
+   * 应用with参数覆盖默认的序列化器实例化代码
+   * @param withParam 自定义序列化器表达式
+   * @param defaultInstantiation 默认实例化代码
+   * @param structure 类型结构
+   */
+  protected applyWithParam(withParam: string | undefined, defaultInstantiation: string, structure: TypeStructure): string {
+    if (!withParam) {
+      return defaultInstantiation;
+    }
+
+    // 检查是否包含泛型类型
+    if (this.containsGenericType(structure)) {
+      return `new WithEntrySerializer(${withParam}, [${this.generateTypeKeySerializers(structure)}])`;
+    } else {
+      return `new WithEntryContextualSerializer(${withParam}, [${this.generateTypeKeys(structure)}])`;
+    }
+  }
+
+  /**
+   * 检查类型结构中是否包含泛型类型参数
+   */
+  protected containsGenericType(structure: TypeStructure): boolean {
+    // 检查当前节点是否为泛型
+    if (structure.kind === PropertyKind.GENERIC) {
+      return true;
+    }
+
+    // 递归检查泛型参数（如 Array<T>, Map<K,V>）
+    if (structure.args && structure.args.length > 0) {
+      return structure.args.some(arg => this.containsGenericType(arg));
+    }
+
+    // 递归检查联合类型的成员（如 T | string | number）
+    if (structure.unionDetails && structure.unionDetails.length > 0) {
+      return structure.unionDetails.some(member => this.containsGenericType(member));
+    }
+
+    return false;
+  }
+
+  /**
+   * 生成类型键序列化器数组（用于泛型类型的with参数）
+   * @example Array<T> -> [Serializer<T>]
+   */
+  protected generateTypeKeySerializers(structure: TypeStructure): string {
+    if (structure.args && structure.args.length > 0) {
+      // 需要导入TypeHandlerRegistry来生成实例化代码
+      const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+      return structure.args.map((arg) => {
+        return TypeHandlerRegistry.getInstance().generateInstantiation(arg);
+      }).join(',\n');
+    }
+    return '';
+  }
+
+  /**
+   * 生成类型键数组（用于非泛型类型的with参数）
+   * @example Array<string> -> ['string']
+   */
+  protected generateTypeKeys(structure: TypeStructure): string {
+    if (structure.args && structure.args.length > 0) {
+      const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+      return structure.args.map(arg => {
+        return TypeHandlerRegistry.getInstance().generateTypeKey(arg);
+      }).join(', ');
+    }
+    return '';
+  }
+}

package/src/core/handlers/CustomClassHandler.ts

@@ -0,0 +1,278 @@
+/*
+ * 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, SyntaxKind, TypeReferenceNode } from 'ts-morph';
+import { BaseTypeHandler } from './BaseTypeHandler';
+import { ITypeHandler, TypeContext, ConversionDirection } from './ITypeHandler';
+import {
+  PropertyKind,
+  TypeStructure,
+  SerializerMetadata,
+  TypeDependency,
+  ClassDetails,
+  TypeKind,
+  TypeAliasDetails,
+  InterfaceDetails
+} from '../Types';
+import { CustomTypeAnalyzer } from '../analyzers/CustomTypeAnalyzer';
+import { ClassAnalyzer } from '../analyzers/ClassAnalyzer';
+import { CustomError, ErrorCodes } from '../utils/CustomError';
+
+export class CustomClassHandler extends BaseTypeHandler implements ITypeHandler {
+  readonly name = 'CustomClassHandler';
+  readonly kind = PropertyKind.OBJECT;
+  readonly priority = 10; // 最低优先级，作为fallback
+
+  // ==================== 阶段1: 类型识别 ====================
+
+  matches(typeNode: TypeNode): boolean {
+    // 如果是TypeReference且没有被其他Handler处理，就是自定义类
+    return typeNode.getKind() === SyntaxKind.TypeReference;
+  }
+
+  // ==================== 阶段2: 类型解析 ====================
+
+  parse(typeNode: TypeNode, context: TypeContext): TypeStructure {
+    const typeRef = typeNode as TypeReferenceNode;
+    const customTypeName = typeRef.getTypeName().getText();
+    const typeArgs = typeRef.getTypeArguments();
+
+    // ✅ 递归解析泛型参数
+    const { dependencies, parsedArgs } = this.parseGenericArguments(typeArgs, context);
+
+    // ✅ 查找类型定义并收集依赖
+    const typeDependency = CustomTypeAnalyzer.getInstance()
+      .findDefinition(customTypeName, typeRef.getSourceFile());
+
+    if (!typeDependency) {
+      return this.handleMissingTypeDependency(customTypeName);
+    }
+
+    // 处理 Type 类型别名：直接使用已解析的类型结构
+    if (typeDependency.typeKind === TypeKind.TYPE) {
+      return this.handleTypeAlias(typeDependency, typeNode);
+    }
+
+    // 计算深度
+    const maxArgDepth = parsedArgs.length > 0
+      ? Math.max(...parsedArgs.map(arg => arg.depth))
+      : 0;
+
+    if (typeDependency.typeKind === TypeKind.INTERFACE) {
+      return {
+        kind: this.kind,
+        depth: parsedArgs.length > 0 ? 1 + maxArgDepth : 0,
+        sourceText: typeNode.getText(), // ✅ 使用完整类型文本（包含泛型参数）
+        interfaceDetails: typeDependency.details as InterfaceDetails,
+        args: parsedArgs, // ✅ 填充泛型参数
+        dependencies: [typeDependency, ...dependencies] // ✅ 填充依赖
+      };
+    } else if (typeDependency.typeKind === TypeKind.CLASS) {
+      return {
+        kind: this.kind,
+        depth: parsedArgs.length > 0 ? 1 + maxArgDepth : 0,
+        sourceText: typeNode.getText(), // ✅ 使用完整类型文本（包含泛型参数）
+        classDetails: typeDependency.details as ClassDetails,
+        args: parsedArgs, // ✅ 填充泛型参数
+        dependencies: [typeDependency, ...dependencies] // ✅ 填充依赖
+      };
+    } else {
+      return {
+        kind: PropertyKind.UNKNOWN,
+        depth: 0,
+        sourceText: customTypeName,
+        args: [],
+        dependencies: []
+      };
+    }
+  }
+
+  private parseGenericArguments(typeArgs: TypeNode[], context: TypeContext): { 
+    dependencies: TypeDependency[]; 
+    parsedArgs: TypeStructure[] 
+  } {
+    const dependencies: TypeDependency[] = [];
+    const parsedArgs: TypeStructure[] = typeArgs.map(arg => {
+      const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+      const argStructure = TypeHandlerRegistry.getInstance().parseType(arg, {
+        ...context,
+        depth: context.depth + 1
+      });
+      dependencies.push(...argStructure.dependencies);
+      return argStructure;
+    });
+    
+    return { dependencies, parsedArgs };
+  }
+
+  private handleMissingTypeDependency(customTypeName: string): TypeStructure {
+    // 未找到类型定义，返回 UNKNOWN 类型结构
+    // ClassAnalyzer 会检查是否有 @Transient 注解来决定如何处理
+    return {
+      kind: PropertyKind.UNKNOWN,
+      depth: 0,
+      sourceText: customTypeName,
+      args: [],
+      dependencies: []
+    };
+  }
+
+  private handleTypeAlias(typeDependency: TypeDependency, typeNode: TypeNode): TypeStructure {
+    const typeAliasDetails = typeDependency.details as TypeAliasDetails;
+
+    return {
+      ...typeAliasDetails.resolvedType,
+      sourceText: typeNode.getText(), // 保留类型别名名称用于生成代码
+      dependencies: [typeDependency, ...typeAliasDetails.resolvedType.dependencies]
+    };
+  }
+
+  // ==================== 阶段3: 序列化器配置 ====================
+
+  getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata {
+    const serializerName = `${structure.sourceText}Serializer`;
+    const defaultInstantiation = this.generateInstantiation(structure);
+
+    return {
+      name: serializerName,
+      typeDeclaration: this.generateTypeDeclaration(structure, withParam),
+      instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+      encodeMethod: 'encodeSerializableElement',
+      decodeMethod: 'deserialize',
+      decoderType: `${structure.sourceText} | undefined`,
+      needsTypeAssertion: false
+    };
+  }
+
+  // ==================== 阶段4: 代码生成 ====================
+
+  generateInstantiation(structure: TypeStructure): string {
+    // ✅ 泛型对象：new UserSerializerFactory().getSerializer(T1Serializer, T2Serializer)
+    if (structure.args && structure.args.length > 0) {
+      const typeName = structure.sourceText.slice(0, structure.sourceText.indexOf('<'));
+      const argsSerializers = structure.args.map(arg => {
+        const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+        const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(arg.kind);
+        return handler.generateInstantiation(arg);
+      });
+
+      return `new ${typeName}SerializerFactory().getSerializer(${argsSerializers.join(', ')})`;
+    }
+
+    // ✅ 非泛型对象：UserSerializer.INSTANCE
+    const typeName = structure.sourceText;
+    return `${typeName}Serializer.INSTANCE`;
+  }
+
+  generateTypeDeclaration(structure: TypeStructure, withParam?: string): string {
+    // ✅ 泛型对象：Serializer<User<T>>
+    if (structure.args && structure.args.length > 0) {
+      return `Serializer<${structure.sourceText}>`;
+    }
+
+    if (withParam) {
+      // ✅ 泛型对象：Serializer<User<T>>
+      return `Serializer<${structure.sourceText}>`;
+    }
+
+    // ✅ 非泛型对象：UserSerializer
+    return `${structure.sourceText}Serializer`;
+  }
+
+  generateTypeKey(structure: TypeStructure): string {
+    // ✅ 泛型对象：{ classKey: 'User', genericTypes: [T1Key, T2Key] }
+    if (structure.args && structure.args.length > 0) {
+      const classKey = structure.sourceText.slice(0, structure.sourceText.indexOf('<'));
+      const genericKeys = structure.args.map(arg => {
+        const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+        const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(arg.kind);
+        return handler.generateTypeKey(arg);
+      });
+
+      return `{ classKey: '${classKey}', genericTypes: [${genericKeys.join(', ')}] }`;
+    }
+
+    // ✅ 非泛型对象：直接返回类名
+    return structure.sourceText;
+  }
+
+  // ==================== Sendable转换 ====================
+
+  generateSendableTypeDeclaration(structure: TypeStructure): string {
+    // 检查类是否启用了generateSendable
+    const classDetails = structure.classDetails;
+    if (!classDetails || !classDetails.classDecl) {
+      // 没有类声明信息，保持原类型
+      return structure.sourceText;
+    }
+
+    const classAnalysis = ClassAnalyzer.analyzeClass(classDetails.classDecl);
+    if (classAnalysis.decorators.serializable?.generateSendable) {
+      // 如果启用了generateSendable，添加Sendable前缀
+      const typeName = structure.sourceText;
+      if (structure.args && structure.args.length > 0) {
+        // 泛型类：User<T> -> SendableUser<T>
+        const className = typeName.slice(0, typeName.indexOf('<'));
+        const genericPart = typeName.slice(typeName.indexOf('<'));
+        return `Sendable${className}${genericPart}`;
+      } else {
+        // 非泛型类：User -> SendableUser
+        return `Sendable${typeName}`;
+      }
+    }
+
+    // 类装饰器上面没有@Sendable or @Serializable({ generateSendable: true })装饰器
+    if (classDetails.classDecl.getDecorator('Sendable')) {
+      return structure.sourceText;
+    } else {
+      throw new CustomError(`Type ${classDetails.classDecl.getName()} is not sendable.
+        please add @Sendable or @Serializable({ generateSendable: true })`, ErrorCodes.NOT_SENDABLE);
+    }
+
+    // 未启用generateSendable，返回原类型
+    return structure.sourceText;
+  }
+
+  generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string {
+    // 检查类是否启用了generateSendable
+    const classDetails = structure.classDetails;
+    if (!classDetails || !classDetails.classDecl) {
+      // 没有类声明信息，直接返回
+      return sourceValue;
+    }
+
+    const classAnalysis = ClassAnalyzer.analyzeClass(classDetails.classDecl);
+    if (classAnalysis.decorators.serializable?.generateSendable) {
+      // 启用了generateSendable，需要调用转换方法
+      if (direction === ConversionDirection.TO_SENDABLE) {
+        // 普通对象 -> Sendable对象：调用toSendable方法
+        return `${sourceValue}.toSendable()`;
+      } else {
+        // Sendable对象 -> 普通对象：调用toOrigin方法
+        return `${sourceValue}.toOrigin()`;
+      }
+    }
+
+    // 未启用generateSendable，直接传递
+    return sourceValue;
+  }
+}
+
+/**
+ * 工厂函数
+ */
+export function createCustomClassHandler(): ITypeHandler {
+  return new CustomClassHandler();
+}

package/src/core/handlers/DateHandler.ts

@@ -0,0 +1,75 @@
+/*
+ * 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 { SyntaxKind, TypeNode, TypeReferenceNode } from 'ts-morph';
+import { PropertyKind, TypeStructure, SerializerMetadata } from '../Types';
+import { BaseTypeHandler } from './BaseTypeHandler';
+import { TypeContext, ConversionDirection, ITypeHandler } from './ITypeHandler';
+
+class DateHandler extends BaseTypeHandler implements ITypeHandler {
+    readonly name: string = 'DateHandler';
+    kind: PropertyKind = PropertyKind.Date;
+    priority: number = 95;
+    matches(typeNode: TypeNode, context: TypeContext): boolean {
+        if (typeNode.getKind() === SyntaxKind.TypeReference) {
+            const typeRef = typeNode as TypeReferenceNode;
+            const refName = typeRef.getTypeName().getText();
+            return refName === 'Date';
+        }
+        return false;
+    }
+    parse(typeNode: TypeNode, context: TypeContext): TypeStructure {
+        return {
+            kind: PropertyKind.Date,
+            depth: 0,
+            sourceText: typeNode.getText(),
+            args: [],
+            dependencies: []
+        };
+    }
+    getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata {
+        return {
+            name: 'DateSerializer',
+            typeDeclaration: 'DateSerializer',
+            instantiationTemplate: 'DateSerializer.INSTANCE',
+            encodeMethod: 'encodeSerializableElement',
+            decodeMethod: 'deserialize',
+            decoderType: 'Date | undefined',
+            needsTypeAssertion: false
+        };
+    }
+    generateInstantiation(structure: TypeStructure): string {
+        return 'DateSerializer.INSTANCE';
+    }
+    generateTypeDeclaration(structure: TypeStructure): string {
+        return 'DateSerializer';
+    }
+    generateTypeKey(structure: TypeStructure): string {
+        return structure.sourceText;
+    }
+    generateSendableTypeDeclaration(structure: TypeStructure): string {
+        return structure.sourceText;
+    }
+    generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string {
+        return sourceValue;
+    }
+}
+
+/**
+ * 工厂函数
+ */
+export function createDateHandler(): ITypeHandler {
+    return new DateHandler();
+}