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

package/src/core/handlers/TypeHandlerRegistry.ts

@@ -0,0 +1,236 @@
+/*
+ * 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, InferTypeNode } from 'ts-morph';
+import { ITypeHandler, TypeContext } from './ITypeHandler';
+import { PropertyKind, TypeStructure, Logger } from '..';
+import { CustomError, ErrorCodes } from '../utils/CustomError';
+
+export class TypeHandlerRegistry {
+  private static instance: TypeHandlerRegistry;
+
+  /** 所有已注册的处理器（按注册顺序） */
+  private handlers: ITypeHandler[] = [];
+
+  /** Kind到Handler的快速查找表 */
+  private kindMap: Map<PropertyKind, ITypeHandler> = new Map();
+
+  /** 类型名称到Handler的快速查找表（支持多个候选） */
+  private nameMap: Map<string, ITypeHandler[]> = new Map();
+
+  private constructor() { }
+
+  /**
+   * 获取单例实例
+   */
+  static getInstance(): TypeHandlerRegistry {
+    if (!TypeHandlerRegistry.instance) {
+      TypeHandlerRegistry.instance = new TypeHandlerRegistry();
+    }
+    return TypeHandlerRegistry.instance;
+  }
+
+  // ==================== 注册管理 ====================
+
+  /**
+   * 注册类型处理器
+   * @param handler 类型处理器实例
+   */
+  register(handler: ITypeHandler): void {
+    // 添加到列表
+    this.handlers.push(handler);
+
+    // 按优先级排序（优先级高的在前）
+    this.handlers.sort((a, b) => b.priority - a.priority);
+
+    // 更新Kind映射（只保留最高优先级）
+    const existingHandler = this.kindMap.get(handler.kind);
+    if (!existingHandler || handler.priority > existingHandler.priority) {
+      this.kindMap.set(handler.kind, handler);
+    }
+
+    // 更新类型名称映射（支持多个候选）
+    const typeName = this.extractTypeName(handler.kind);
+    const candidates = this.nameMap.get(typeName) || [];
+    candidates.push(handler);
+    candidates.sort((a, b) => b.priority - a.priority);
+    this.nameMap.set(typeName, candidates);
+  }
+
+  /**
+   * 批量注册处理器
+   * @param handlers 处理器数组
+   */
+  registerAll(handlers: ITypeHandler[]): void {
+    handlers.forEach((handler) => this.register(handler));
+  }
+
+  // ==================== 处理器查找 ====================
+
+  /**
+   * 根据PropertyKind查找处理器
+   * @param kind PropertyKind
+   * @returns 对应的处理器，如果不存在返回undefined
+   */
+  getHandlerForKind(kind: PropertyKind): ITypeHandler {
+    const handler = this.kindMap.get(kind);
+    if (!handler) {
+      // 理论上走不到这里来
+      throw new CustomError(`No handler for kind: ${kind}`, ErrorCodes.HANDLER_NOT_FOUND);
+    }
+    return handler;
+  }
+
+  /**
+   * 根据类型节点查找匹配的处理器
+   * @param typeNode AST类型节点
+   * @param context 上下文
+   * @returns 匹配的处理器，如果没有匹配返回undefined
+   */
+  findHandler(typeNode: TypeNode, context: TypeContext): ITypeHandler | undefined {
+    const typeName = typeNode.getText();
+
+    // 策略1: 先尝试类型名称精确匹配
+    const candidates = this.nameMap.get(this.normalizeTypeName(typeName));
+    if (candidates && candidates.length > 0) {
+      for (const handler of candidates) {
+        if (handler.matches(typeNode, context)) {
+          return handler;
+        }
+      }
+    }
+
+    // 策略2: 遍历所有处理器（按优先级顺序）
+    for (const handler of this.handlers) {
+      if (handler.matches(typeNode, context)) {
+        return handler;
+      }
+    }
+
+    Logger.warn(`No handler found for type: ${typeName}`);
+    return undefined;
+  }
+
+  // ==================== 类型解析入口 ====================
+
+  /**
+   * 解析类型节点为类型结构
+   * @param typeNode AST类型节点
+   * @param context 类型上下文
+   * @returns 类型结构
+   */
+  parseType(typeNode: TypeNode, context: TypeContext): TypeStructure {
+
+    // 字面量类型检测：除了 null 和 undefined，其他字面量类型都不支持
+    if (typeNode.getKind() === SyntaxKind.LiteralType) {
+      const literal = typeNode.asKindOrThrow(SyntaxKind.LiteralType);
+      const literalValue = literal.getLiteral();
+      const literalKind = literalValue.getKind();
+
+      // 允许 null 和 undefined 字面量
+      if (literalKind !== SyntaxKind.NullKeyword && literalKind !== SyntaxKind.UndefinedKeyword) {
+        throw new CustomError(
+          `不支持字面量类型 '${typeNode.getText()}'（无论出现在何处）。\n` +
+          `不支持的字面量类型包括：字符串字面量（如 'admin'）、数字字面量（如 123）、布尔字面量（如 true）。\n` +
+          `即使在联合类型、Type 别名、泛型参数中使用字面量也不支持。\n` +
+          `请使用基础类型：string、number、boolean 替代字面量类型。`,
+          ErrorCodes.LITERAL_NOT_SOPPORT);
+      }
+    }
+
+    // 处理 ParenthesizedType (括号类型)例如 (string|number)
+    if (typeNode.getKind() === SyntaxKind.ParenthesizedType) {
+      // 对于括号类型，我们解析其内部的类型
+      const parenthesizedType = typeNode.asKindOrThrow(SyntaxKind.ParenthesizedType);
+      const innerTypeNode = parenthesizedType.getTypeNode();
+
+      // 递归解析括号内的类型
+      return this.parseType(innerTypeNode, context);
+    }
+
+    const handler = this.findHandler(typeNode, context);
+    if (!handler) {
+      // 容错机制：找不到处理器时返回 UNKNOWN 类型
+      // ClassAnalyzer 会检查是否有 @Transient 注解来决定如何处理
+      const typeName = typeNode.getText();
+      Logger.warn(`No handler found for type: ${typeName}, marking as UNKNOWN`);
+
+      return {
+        kind: PropertyKind.UNKNOWN,
+        depth: 0,
+        sourceText: typeName,
+        args: [],
+        dependencies: []
+      };
+    }
+
+    return handler.parse(typeNode, context);
+  }
+
+  // ==================== 代码生成入口 ====================
+
+  /**
+   * 生成序列化器实例化代码
+   * @param structure 类型结构
+   * @returns 实例化代码字符串
+   */
+  generateInstantiation(structure: TypeStructure): string {
+    const handler = this.getHandlerForKind(structure.kind);
+
+    return handler.generateInstantiation(structure);
+  }
+
+  generateTypeKey(structure: TypeStructure): string {
+    const handler = this.getHandlerForKind(structure.kind);
+
+    return handler.generateTypeKey(structure);
+  }
+
+  // ==================== 辅助方法 ====================
+
+  /**
+   * 从PropertyKind提取类型名称
+   * @param kind PropertyKind
+   * @returns 类型名称
+   * @example 'string' -> 'string', 'array' -> 'Array', 'collections.Array' -> 'Array'
+   */
+  private extractTypeName(kind: PropertyKind): string {
+    // 处理collections.*类型
+    if (kind.startsWith('collections.')) {
+      return kind.split('.')[1];
+    }
+
+    // 基础类型直接返回
+    return kind;
+  }
+
+  /**
+   * 规范化类型名称（用于查找）
+   * @param typeName 原始类型名称
+   * @returns 规范化后的名称
+   * @example 'Array<string>' -> 'Array', 'collections.Array<T>' -> 'Array'
+   */
+  private normalizeTypeName(typeName: string): string {
+    // 移除泛型参数
+    const withoutGenerics = typeName.split('<')[0].trim();
+
+    // 处理collections.*
+    if (withoutGenerics.startsWith('collections.')) {
+      return withoutGenerics.split('.')[1];
+    }
+
+    return withoutGenerics;
+  }
+}

package/src/core/handlers/UnionTypeHandler.ts

@@ -0,0 +1,400 @@
+/*
+ * 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, UnionTypeNode } from 'ts-morph';
+import { PropertyKind, TypeStructure, SerializerMetadata, TypeDependency } from '../Types';
+import { ITypeHandler, TypeContext, ConversionDirection } from './ITypeHandler';
+import { BaseTypeHandler } from './BaseTypeHandler';
+import { CustomError, ErrorCodes } from '../utils/CustomError';
+
+type UnionPattern = 'optional' | 'nullable' | 'union' | 'optionalNullable';
+
+abstract class UnionTypeHandler extends BaseTypeHandler implements ITypeHandler {
+  abstract readonly name: string;
+  abstract readonly kind: PropertyKind;
+  abstract readonly priority: number;
+
+  /**
+   * 子类指定支持的联合类型模式
+   */
+  protected abstract readonly supportedPattern: UnionPattern;
+
+  // ==================== 阶段1: 类型识别 ====================
+
+  matches(typeNode: TypeNode): boolean {
+    // 必须是UnionType
+    if (typeNode.getKind() !== SyntaxKind.UnionType) {
+      return false;
+    }
+
+    const unionType = typeNode as UnionTypeNode;
+    const memberTypes = unionType.getTypeNodes();
+
+    // 辅助函数：检查是否为 null 类型节点
+    const isNullType = (t: TypeNode): boolean => {
+      return t.getKind() === SyntaxKind.LiteralType && t.getText() === 'null';
+    };
+
+    // 辅助函数：检查是否为 undefined 类型节点
+    const isUndefinedType = (t: TypeNode): boolean => {
+      return t.getKind() === SyntaxKind.UndefinedKeyword;
+    };
+
+    // 根据supportedPattern匹配不同的联合类型模式
+    switch (this.supportedPattern) {
+      case 'optional':
+        // T | undefined （必须是2个成员，其中一个是undefined，另一个不是null）
+        if (memberTypes.length !== 2) {
+          return false;
+        }
+        const hasUndefined = memberTypes.some(isUndefinedType);
+        const hasNull = memberTypes.some(isNullType);
+        // 确保有undefined，但另一个成员不是null
+        return hasUndefined && !hasNull;
+
+      case 'nullable':
+        // T | null （必须是2个成员，其中一个是null，另一个不是undefined）
+        if (memberTypes.length !== 2) {
+          return false;
+        }
+        const hasNullable = memberTypes.some(isNullType);
+        const hasUndefinedNullable = memberTypes.some(isUndefinedType);
+        // 确保有null，但另一个成员不是undefined
+        return hasNullable && !hasUndefinedNullable;
+
+      case 'optionalNullable':
+        // T | null | undefined （必须是3个成员，包含null和undefined，还有一个其他类型）
+        return memberTypes.length === 3 &&
+          memberTypes.some(isNullType) &&
+          memberTypes.some(isUndefinedType);
+
+      case 'union':
+        // 普通联合类型（其他所有联合类型）
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
+  // ==================== 阶段2: 类型解析 ====================
+
+  parse(typeNode: TypeNode, context: TypeContext): TypeStructure {
+    const unionType = typeNode as UnionTypeNode;
+
+    // 统一解析所有成员类型
+    const members = this.parseUnionMembers(unionType, context);
+
+    // 收集所有依赖
+    const allDependencies: TypeDependency[] = [];
+    let maxDepth = 0;
+    members.forEach(member => {
+      allDependencies.push(...member.dependencies);
+      maxDepth = Math.max(maxDepth, member.depth);
+    });
+
+    return {
+      kind: this.kind,
+      depth: this.supportedPattern === 'union' ? 0 : maxDepth + 1,
+      sourceText: typeNode.getText(),
+      args: [],
+      dependencies: allDependencies,
+      unionDetails: members
+    };
+  }
+
+  // ==================== 阶段3: 序列化器配置 ====================
+
+  getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata {
+    const serializerName = this.getSerializerName();
+    const defaultInstantiation = this.generateInstantiation(structure);
+
+    return {
+      name: serializerName,
+      typeDeclaration: this.generateTypeDeclaration(structure),
+      instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+      encodeMethod: 'encodeSerializableElement',
+      decodeMethod: 'deserialize',
+      decoderType: `${structure.sourceText} | undefined`,
+      needsTypeAssertion: false
+    };
+  }
+
+  // ==================== 阶段4: 代码生成 ====================
+
+  generateInstantiation(structure: TypeStructure): string {
+    if (!structure.unionDetails || structure.unionDetails.length === 0) {
+      throw new CustomError(`${this.name}: missing unionDetails`, ErrorCodes.UNION_STRUCTURE_NOT_FOUND);
+    }
+
+    const serializerName = this.getSerializerName();
+
+    // 处理Optional/Nullable/OptionalNullable模式
+    if (this.isOptionalOrNullablePattern()) {
+      return this.generateOptionalNullableInstantiation(structure);
+    }
+
+    // Union: 所有成员类型
+    const primitiveTypes = ['undefined', 'null', 'boolean', 'number', 'string', 'bigint'];
+    const unionTypes = structure.unionDetails.map(member => {
+      return primitiveTypes.includes(member.sourceText)
+        ? `'${member.sourceText}'`
+        : member.sourceText;
+    }).join(', ');
+
+    const typeDeclaration = structure.unionDetails.map(member => member.sourceText).join(' | ');
+    return `new ${serializerName}<${typeDeclaration}>([${unionTypes}])`;
+  }
+
+  generateTypeDeclaration(structure: TypeStructure): string {
+    if (!structure.unionDetails || structure.unionDetails.length === 0) {
+      throw new CustomError(`${this.name}: missing unionDetails`, ErrorCodes.UNION_STRUCTURE_NOT_FOUND);
+    }
+
+    const serializerName = this.getSerializerName();
+
+    // 处理Optional/Nullable/OptionalNullable模式
+    if (this.isOptionalOrNullablePattern()) {
+      const innerMember = this.getInnerMember(structure);
+      if (!innerMember) {
+        throw new CustomError(`${this.name}: cannot find inner member`, ErrorCodes.UNION_INNER_NOT_FOUND);
+      }
+
+      return `${serializerName}<${innerMember.sourceText}>`;
+    }
+
+    // Union: 所有成员类型
+    const typeDeclaration = structure.unionDetails.map(member => member.sourceText).join(' | ');
+    return `${serializerName}<${typeDeclaration}>`;
+  }
+
+  generateTypeKey(structure: TypeStructure): string {
+    if (!structure.unionDetails || structure.unionDetails.length === 0) {
+      throw new CustomError(`${this.name}: missing unionDetails`, ErrorCodes.UNION_STRUCTURE_NOT_FOUND);
+    }
+
+    // 处理Optional/Nullable/OptionalNullable模式
+    if (this.isOptionalOrNullablePattern()) {
+      return this.generateOptionalNullableTypeKey(structure);
+    }
+
+    // Union: 所有成员typeKey的数组
+    const memberTypeKeys = structure.unionDetails.map(member => {
+      const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+      const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(member.kind);
+      return handler.generateTypeKey(member);
+    });
+
+    return `[${memberTypeKeys.join(', ')}]`;
+  }
+
+  // ==================== Protected 工具方法 ====================
+
+  /**
+   * 检查是否为Optional、Nullable或OptionalNullable模式
+   */
+  protected isOptionalOrNullablePattern(): boolean {
+    return this.supportedPattern === 'optional' || 
+           this.supportedPattern === 'nullable' || 
+           this.supportedPattern === 'optionalNullable';
+  }
+
+  /**
+   * 获取Optional/Nullable/OptionalNullable模式的内部成员类型
+   */
+  protected getInnerMember(structure: TypeStructure): TypeStructure | undefined {
+    switch (this.supportedPattern) {
+      case 'optional':
+        return structure.unionDetails?.find(m => m.kind !== PropertyKind.UNDEFINED);
+      case 'nullable':
+        return structure.unionDetails?.find(m => m.kind !== PropertyKind.NULL);
+      case 'optionalNullable':
+        return structure.unionDetails?.find(m => 
+          m.kind !== PropertyKind.NULL && m.kind !== PropertyKind.UNDEFINED
+        );
+      default:
+        return undefined;
+    }
+  }
+
+  /**
+   * 生成Optional/Nullable/OptionalNullable模式的实例化代码
+   */
+  protected generateOptionalNullableInstantiation(structure: TypeStructure): string {
+    if (this.supportedPattern === 'optionalNullable' && structure.unionDetails?.length !== 3) {
+      throw new CustomError(`${this.name}: expected 3 union members`, ErrorCodes.UNION_EXPEDTED_THREE);
+    }
+    
+    if (this.supportedPattern !== 'optionalNullable' && structure.unionDetails?.length !== 2) {
+      throw new CustomError(`${this.name}: expected 2 union members`, ErrorCodes.UNION_EXPEDTED_TWO);
+    }
+
+    const innerMember = this.getInnerMember(structure);
+    if (!innerMember) {
+      throw new CustomError(`${this.name}: cannot find inner member`, ErrorCodes.UNION_INNER_NOT_FOUND);
+    }
+
+    const innerType = innerMember.sourceText;
+    const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+    const innerHandler = TypeHandlerRegistry.getInstance().getHandlerForKind(innerMember.kind);
+
+    const innerSerializer = innerHandler.generateInstantiation(innerMember);
+    const serializerName = this.getSerializerName();
+    return `new ${serializerName}<${innerType}>(${innerSerializer})`;
+  }
+
+  /**
+   * 生成Optional/Nullable/OptionalNullable模式的类型键
+   */
+  protected generateOptionalNullableTypeKey(structure: TypeStructure): string {
+    const innerMember = this.getInnerMember(structure);
+    if (!innerMember) {
+      throw new CustomError(`${this.name}: cannot find inner member`, ErrorCodes.UNION_INNER_NOT_FOUND);
+    }
+
+    const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+    const innerHandler = TypeHandlerRegistry.getInstance().getHandlerForKind(innerMember.kind);
+    const innerTypeKey = innerHandler.generateTypeKey(innerMember);
+    
+    switch (this.supportedPattern) {
+      case 'optional':
+        return `[${innerTypeKey}, "'undefined'"]`;
+      case 'nullable':
+        return `[${innerTypeKey}, "'null'"]`;
+      case 'optionalNullable':
+        return `[${innerTypeKey}, "'null'", "'undefined'"]`;
+      default:
+        throw new CustomError(`${this.name}: unsupported pattern`, ErrorCodes.UNION_UNSUPPORTED_PATTERN);
+    }
+  }
+
+  /**
+   * 解析联合类型的所有成员
+   */
+  protected parseUnionMembers(typeNode: UnionTypeNode, context: TypeContext): TypeStructure[] {
+    const memberTypes = typeNode.getTypeNodes();
+    const members: TypeStructure[] = [];
+
+    for (const memberType of memberTypes) {
+      const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+      const memberStructure = TypeHandlerRegistry.getInstance().parseType(memberType, {
+        ...context,
+        depth: context.depth + 1
+      });
+      members.push(memberStructure);
+    }
+
+    return members;
+  }
+
+  // ==================== Sendable转换 ====================
+
+  generateSendableTypeDeclaration(structure: TypeStructure): string {
+    if (!structure.unionDetails || structure.unionDetails.length === 0) {
+      throw new CustomError(`${this.name}: missing unionDetails for Sendable type declaration`, ErrorCodes.UNION_STRUCTURE_NOT_FOUND);
+    }
+
+    // 递归获取TypeHandlerRegistry
+    const registry = require('./TypeHandlerRegistry').TypeHandlerRegistry.getInstance();
+
+    // 递归转换每个成员类型为Sendable类型
+    const sendableMemberTypes = structure.unionDetails.map(member => {
+      const handler = registry.getHandlerForKind(member.kind);
+      if (!handler) {
+        throw new CustomError(`${this.name}: no handler for member type: ${member.kind}`, ErrorCodes.HANDLER_NOT_FOUND);
+      }
+      return handler.generateSendableTypeDeclaration(member);
+    });
+
+    // 联合所有Sendable成员类型
+    return sendableMemberTypes.join(' | ');
+  }
+
+  generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string {
+    // 联合类型的转换无法在编译时确定具体类型，直接传递
+    // 实际转换由运行时的具体类型决定
+    // 注意：这可能需要在运行时检查类型并调用相应的转换方法
+    return sourceValue;
+  }
+}
+
+class NullableHandler extends UnionTypeHandler {
+  readonly name = 'NullableHandler';
+  readonly kind = PropertyKind.NULLABLE;
+  readonly priority = 95; // 高于普通UnionHandler
+  protected readonly supportedPattern = 'nullable' as const;
+
+  protected getSerializerName(): string {
+    return 'NullableSerializer';
+  }
+}
+
+class OptionalHandler extends UnionTypeHandler {
+  readonly name = 'OptionalHandler';
+  readonly kind = PropertyKind.OPTIONAL;
+  readonly priority = 95; // 高于普通UnionHandler
+  protected readonly supportedPattern = 'optional' as const;
+
+  protected getSerializerName(): string {
+    return 'OptionalSerializer';
+  }
+}
+
+class OptionalNullableHandler extends UnionTypeHandler {
+  readonly name = 'OptionalNullableHandler';
+  readonly kind = PropertyKind.OPTIONAL_NULLABLE;
+  readonly priority = 95; // 高于普通UnionHandler
+  protected readonly supportedPattern = 'optionalNullable' as const;
+
+  protected getSerializerName(): string {
+    return 'OptionalNullableSerializer';
+  }
+}
+
+class UnionHandler extends UnionTypeHandler {
+  readonly name = 'UnionHandler';
+  readonly kind = PropertyKind.UNION;
+  readonly priority = 85; // 低于Optional和Nullable，作为fallback
+  protected readonly supportedPattern = 'union' as const;
+
+  protected getSerializerName(): string {
+    return 'UnionTypeSerializer';
+  }
+}
+
+/**
+ * 工厂函数：创建所有联合类型Handler
+ * @returns 4个联合类型Handler实例
+ *
+ * 优先级顺序（从高到低）：
+ * 1. OptionalHandler (95) - T | undefined (T不为null)
+ * 2. NullableHandler (95) - T | null (T不为undefined)
+ * 3. OptionalNullableHandler (95) - T | null | undefined (T为其他类型)
+ * 4. UnionHandler (85) - 其他所有联合类型 (包括 null | undefined)
+ *
+ * 特殊情况说明：
+ * - `null | undefined` 会被 UnionHandler 处理，生成 UnionTypeSerializer<null | undefined>
+ * - `T | undefined` (T非null) 会被 OptionalHandler 处理，生成 OptionalSerializer<T>
+ * - `T | null` (T非undefined) 会被 NullableHandler 处理，生成 NullableSerializer<T>
+ * - `T | null | undefined` 会被 OptionalNullableHandler 处理，生成 OptionalNullableSerializer<T>
+ */
+export function createUnionTypeHandlers(): ITypeHandler[] {
+  return [
+    new OptionalHandler(),
+    new NullableHandler(),
+    new OptionalNullableHandler(),
+    new UnionHandler()
+  ];
+}

package/src/core/handlers/index.ts

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+
+export type { ITypeHandler, TypeContext } from './ITypeHandler';
+
+export { TypeHandlerRegistry } from './TypeHandlerRegistry';