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

package/dist/core/handlers/PrimitiveHandler.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrimitiveHandlers = createPrimitiveHandlers;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+class PrimitiveHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.priority = 100;
+    }
+    matches(typeNode) {
+        return typeNode.getKind() === this.syntaxKind;
+    }
+    parse(typeNode) {
+        return {
+            kind: this.kind,
+            depth: 0,
+            sourceText: typeNode.getText(),
+            args: [],
+            dependencies: []
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        const serializerName = this.getSerializerName();
+        const defaultInstantiation = this.generateInstantiation();
+        return {
+            name: serializerName,
+            typeDeclaration: serializerName,
+            instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+            encodeMethod: `encode${this.getTypeName()}Element`,
+            decodeMethod: `decode${this.getTypeName()}`,
+            decoderType: `${structure.sourceText} | undefined`,
+            needsTypeAssertion: false
+        };
+    }
+    generateInstantiation() {
+        const serializerName = this.getSerializerName();
+        return `${serializerName}.INSTANCE`;
+    }
+    generateTypeDeclaration() {
+        return this.getSerializerName();
+    }
+    generateTypeKey(structure) {
+        return `'${structure.sourceText}'`;
+    }
+    generateSendableTypeDeclaration(structure) {
+        return structure.sourceText;
+    }
+    generatePropertyConversion(_structure, sourceValue) {
+        return sourceValue;
+    }
+}
+class StringHandler extends PrimitiveHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'StringHandler';
+        this.kind = Types_1.PropertyKind.STRING;
+        this.syntaxKind = ts_morph_1.SyntaxKind.StringKeyword;
+    }
+}
+class NumberHandler extends PrimitiveHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'NumberHandler';
+        this.kind = Types_1.PropertyKind.NUMBER;
+        this.syntaxKind = ts_morph_1.SyntaxKind.NumberKeyword;
+    }
+}
+class BooleanHandler extends PrimitiveHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'BooleanHandler';
+        this.kind = Types_1.PropertyKind.BOOLEAN;
+        this.syntaxKind = ts_morph_1.SyntaxKind.BooleanKeyword;
+    }
+}
+class BigintHandler extends PrimitiveHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'BigintHandler';
+        this.kind = Types_1.PropertyKind.BIGINT;
+        this.syntaxKind = ts_morph_1.SyntaxKind.BigIntKeyword;
+    }
+}
+class NullHandler extends PrimitiveHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'NullHandler';
+        this.kind = Types_1.PropertyKind.NULL;
+        this.syntaxKind = ts_morph_1.SyntaxKind.NullKeyword;
+    }
+    matches(typeNode) {
+        if (typeNode.getKind() === ts_morph_1.SyntaxKind.LiteralType) {
+            const literal = typeNode.asKindOrThrow(ts_morph_1.SyntaxKind.LiteralType);
+            const literalValue = literal.getLiteral();
+            return literalValue.getKind() === ts_morph_1.SyntaxKind.NullKeyword;
+        }
+        return typeNode.getKind() === ts_morph_1.SyntaxKind.NullKeyword;
+    }
+}
+class UndefinedHandler extends PrimitiveHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'UndefinedHandler';
+        this.kind = Types_1.PropertyKind.UNDEFINED;
+        this.syntaxKind = ts_morph_1.SyntaxKind.UndefinedKeyword;
+    }
+    matches(typeNode) {
+        if (typeNode.getKind() === ts_morph_1.SyntaxKind.LiteralType) {
+            const literal = typeNode.asKindOrThrow(ts_morph_1.SyntaxKind.LiteralType);
+            const literalValue = literal.getLiteral();
+            return literalValue.getKind() === ts_morph_1.SyntaxKind.UndefinedKeyword;
+        }
+        return typeNode.getKind() === ts_morph_1.SyntaxKind.UndefinedKeyword;
+    }
+}
+function createPrimitiveHandlers() {
+    return [
+        new StringHandler(),
+        new NumberHandler(),
+        new BooleanHandler(),
+        new BigintHandler(),
+        new NullHandler(),
+        new UndefinedHandler()
+    ];
+}

package/dist/core/handlers/TupleHandler.d.ts

@@ -0,0 +1,2 @@
+import { ITypeHandler } from './ITypeHandler';
+export declare function createTupleTypeHandlers(): ITypeHandler;

package/dist/core/handlers/TupleHandler.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTupleTypeHandlers = createTupleTypeHandlers;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+const CustomError_1 = require("../utils/CustomError");
+const Logger_1 = require("../logger/Logger");
+class TupleHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'TupleHandler';
+        this.kind = Types_1.PropertyKind.TUPLE;
+        this.priority = 95;
+    }
+    matches(typeNode) {
+        return typeNode.getKind() === ts_morph_1.SyntaxKind.TupleType;
+    }
+    parse(typeNode, context) {
+        const tupleType = typeNode;
+        const elementTypes = tupleType.getElements();
+        const elements = [];
+        const allDependencies = [];
+        let maxDepth = 0;
+        for (const elementType of elementTypes) {
+            const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+            const elementStructure = TypeHandlerRegistry.getInstance().parseType(elementType, {
+                ...context,
+                depth: context.depth + 1
+            });
+            Logger_1.Logger.info(`tuple element type: ${elementType.getText()}, ${elementStructure.kind}`);
+            elements.push(elementStructure);
+            allDependencies.push(...elementStructure.dependencies);
+            maxDepth = Math.max(maxDepth, elementStructure.depth);
+        }
+        return {
+            kind: this.kind,
+            depth: maxDepth + 1,
+            sourceText: typeNode.getText(),
+            args: elements,
+            dependencies: allDependencies
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        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
+        };
+    }
+    generateInstantiation(structure) {
+        const serializerName = this.getSerializerName();
+        const elementSerializers = structure.args.map(element => {
+            const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+            const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(element.kind);
+            return handler.generateInstantiation(element);
+        });
+        return `new ${serializerName}([${elementSerializers.join(', ')}])`;
+    }
+    generateTypeDeclaration(structure) {
+        const serializerName = this.getSerializerName();
+        return `${serializerName}<${structure.sourceText}>`;
+    }
+    generateTypeKey(structure) {
+        const elementKeys = structure.args.map(element => {
+            const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+            const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(element.kind);
+            return handler.generateTypeKey(element);
+        });
+        return `[${elementKeys.join(', ')}]`;
+    }
+    getSerializerName() {
+        return 'TupleSerializer';
+    }
+    generateSendableTypeDeclaration(structure) {
+        const registry = require('./TypeHandlerRegistry').TypeHandlerRegistry.getInstance();
+        const sendableElementTypes = structure.args.map(element => {
+            const handler = registry.getHandlerForKind(element.kind);
+            if (!handler) {
+                throw new CustomError_1.CustomError(`TupleHandler: no handler for element type: ${element.kind}`, CustomError_1.ErrorCodes.HANDLER_NOT_FOUND);
+            }
+            return handler.generateSendableTypeDeclaration(element);
+        });
+        return `[${sendableElementTypes.join(', ')}]`;
+    }
+    generatePropertyConversion(structure, sourceValue, direction) {
+        return sourceValue;
+    }
+}
+function createTupleTypeHandlers() {
+    return new TupleHandler();
+}

package/dist/core/handlers/TypeHandlerRegistry.d.ts

@@ -0,0 +1,20 @@
+import { TypeNode } from 'ts-morph';
+import { ITypeHandler, TypeContext } from './ITypeHandler';
+import { PropertyKind, TypeStructure } from '..';
+export declare class TypeHandlerRegistry {
+    private static instance;
+    private handlers;
+    private kindMap;
+    private nameMap;
+    private constructor();
+    static getInstance(): TypeHandlerRegistry;
+    register(handler: ITypeHandler): void;
+    registerAll(handlers: ITypeHandler[]): void;
+    getHandlerForKind(kind: PropertyKind): ITypeHandler;
+    findHandler(typeNode: TypeNode, context: TypeContext): ITypeHandler | undefined;
+    parseType(typeNode: TypeNode, context: TypeContext): TypeStructure;
+    generateInstantiation(structure: TypeStructure): string;
+    generateTypeKey(structure: TypeStructure): string;
+    private extractTypeName;
+    private normalizeTypeName;
+}

package/dist/core/handlers/TypeHandlerRegistry.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeHandlerRegistry = void 0;
+const ts_morph_1 = require("ts-morph");
+const __1 = require("..");
+const CustomError_1 = require("../utils/CustomError");
+class TypeHandlerRegistry {
+    constructor() {
+        this.handlers = [];
+        this.kindMap = new Map();
+        this.nameMap = new Map();
+    }
+    static getInstance() {
+        if (!TypeHandlerRegistry.instance) {
+            TypeHandlerRegistry.instance = new TypeHandlerRegistry();
+        }
+        return TypeHandlerRegistry.instance;
+    }
+    register(handler) {
+        this.handlers.push(handler);
+        this.handlers.sort((a, b) => b.priority - a.priority);
+        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);
+    }
+    registerAll(handlers) {
+        handlers.forEach((handler) => this.register(handler));
+    }
+    getHandlerForKind(kind) {
+        const handler = this.kindMap.get(kind);
+        if (!handler) {
+            throw new CustomError_1.CustomError(`No handler for kind: ${kind}`, CustomError_1.ErrorCodes.HANDLER_NOT_FOUND);
+        }
+        return handler;
+    }
+    findHandler(typeNode, context) {
+        const typeName = typeNode.getText();
+        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;
+                }
+            }
+        }
+        for (const handler of this.handlers) {
+            if (handler.matches(typeNode, context)) {
+                return handler;
+            }
+        }
+        __1.Logger.warn(`No handler found for type: ${typeName}`);
+        return undefined;
+    }
+    parseType(typeNode, context) {
+        if (typeNode.getKind() === ts_morph_1.SyntaxKind.LiteralType) {
+            const literal = typeNode.asKindOrThrow(ts_morph_1.SyntaxKind.LiteralType);
+            const literalValue = literal.getLiteral();
+            const literalKind = literalValue.getKind();
+            if (literalKind !== ts_morph_1.SyntaxKind.NullKeyword && literalKind !== ts_morph_1.SyntaxKind.UndefinedKeyword) {
+                throw new CustomError_1.CustomError(`不支持字面量类型 '${typeNode.getText()}'（无论出现在何处）。\n` +
+                    `不支持的字面量类型包括：字符串字面量（如 'admin'）、数字字面量（如 123）、布尔字面量（如 true）。\n` +
+                    `即使在联合类型、Type 别名、泛型参数中使用字面量也不支持。\n` +
+                    `请使用基础类型：string、number、boolean 替代字面量类型。`, CustomError_1.ErrorCodes.LITERAL_NOT_SOPPORT);
+            }
+        }
+        if (typeNode.getKind() === ts_morph_1.SyntaxKind.ParenthesizedType) {
+            const parenthesizedType = typeNode.asKindOrThrow(ts_morph_1.SyntaxKind.ParenthesizedType);
+            const innerTypeNode = parenthesizedType.getTypeNode();
+            return this.parseType(innerTypeNode, context);
+        }
+        const handler = this.findHandler(typeNode, context);
+        if (!handler) {
+            const typeName = typeNode.getText();
+            __1.Logger.warn(`No handler found for type: ${typeName}, marking as UNKNOWN`);
+            return {
+                kind: __1.PropertyKind.UNKNOWN,
+                depth: 0,
+                sourceText: typeName,
+                args: [],
+                dependencies: []
+            };
+        }
+        return handler.parse(typeNode, context);
+    }
+    generateInstantiation(structure) {
+        const handler = this.getHandlerForKind(structure.kind);
+        return handler.generateInstantiation(structure);
+    }
+    generateTypeKey(structure) {
+        const handler = this.getHandlerForKind(structure.kind);
+        return handler.generateTypeKey(structure);
+    }
+    extractTypeName(kind) {
+        if (kind.startsWith('collections.')) {
+            return kind.split('.')[1];
+        }
+        return kind;
+    }
+    normalizeTypeName(typeName) {
+        const withoutGenerics = typeName.split('<')[0].trim();
+        if (withoutGenerics.startsWith('collections.')) {
+            return withoutGenerics.split('.')[1];
+        }
+        return withoutGenerics;
+    }
+}
+exports.TypeHandlerRegistry = TypeHandlerRegistry;

package/dist/core/handlers/UnionTypeHandler.d.ts

@@ -0,0 +1,2 @@
+import { ITypeHandler } from './ITypeHandler';
+export declare function createUnionTypeHandlers(): ITypeHandler[];

package/dist/core/handlers/UnionTypeHandler.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnionTypeHandlers = createUnionTypeHandlers;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+const CustomError_1 = require("../utils/CustomError");
+class UnionTypeHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    matches(typeNode) {
+        if (typeNode.getKind() !== ts_morph_1.SyntaxKind.UnionType) {
+            return false;
+        }
+        const unionType = typeNode;
+        const memberTypes = unionType.getTypeNodes();
+        const isNullType = (t) => {
+            return t.getKind() === ts_morph_1.SyntaxKind.LiteralType && t.getText() === 'null';
+        };
+        const isUndefinedType = (t) => {
+            return t.getKind() === ts_morph_1.SyntaxKind.UndefinedKeyword;
+        };
+        switch (this.supportedPattern) {
+            case 'optional':
+                if (memberTypes.length !== 2) {
+                    return false;
+                }
+                const hasUndefined = memberTypes.some(isUndefinedType);
+                const hasNull = memberTypes.some(isNullType);
+                return hasUndefined && !hasNull;
+            case 'nullable':
+                if (memberTypes.length !== 2) {
+                    return false;
+                }
+                const hasNullable = memberTypes.some(isNullType);
+                const hasUndefinedNullable = memberTypes.some(isUndefinedType);
+                return hasNullable && !hasUndefinedNullable;
+            case 'optionalNullable':
+                return memberTypes.length === 3 &&
+                    memberTypes.some(isNullType) &&
+                    memberTypes.some(isUndefinedType);
+            case 'union':
+                return true;
+            default:
+                return false;
+        }
+    }
+    parse(typeNode, context) {
+        const unionType = typeNode;
+        const members = this.parseUnionMembers(unionType, context);
+        const allDependencies = [];
+        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
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        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
+        };
+    }
+    generateInstantiation(structure) {
+        if (!structure.unionDetails || structure.unionDetails.length === 0) {
+            throw new CustomError_1.CustomError(`${this.name}: missing unionDetails`, CustomError_1.ErrorCodes.UNION_STRUCTURE_NOT_FOUND);
+        }
+        const serializerName = this.getSerializerName();
+        if (this.isOptionalOrNullablePattern()) {
+            return this.generateOptionalNullableInstantiation(structure);
+        }
+        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) {
+        if (!structure.unionDetails || structure.unionDetails.length === 0) {
+            throw new CustomError_1.CustomError(`${this.name}: missing unionDetails`, CustomError_1.ErrorCodes.UNION_STRUCTURE_NOT_FOUND);
+        }
+        const serializerName = this.getSerializerName();
+        if (this.isOptionalOrNullablePattern()) {
+            const innerMember = this.getInnerMember(structure);
+            if (!innerMember) {
+                throw new CustomError_1.CustomError(`${this.name}: cannot find inner member`, CustomError_1.ErrorCodes.UNION_INNER_NOT_FOUND);
+            }
+            return `${serializerName}<${innerMember.sourceText}>`;
+        }
+        const typeDeclaration = structure.unionDetails.map(member => member.sourceText).join(' | ');
+        return `${serializerName}<${typeDeclaration}>`;
+    }
+    generateTypeKey(structure) {
+        if (!structure.unionDetails || structure.unionDetails.length === 0) {
+            throw new CustomError_1.CustomError(`${this.name}: missing unionDetails`, CustomError_1.ErrorCodes.UNION_STRUCTURE_NOT_FOUND);
+        }
+        if (this.isOptionalOrNullablePattern()) {
+            return this.generateOptionalNullableTypeKey(structure);
+        }
+        const memberTypeKeys = structure.unionDetails.map(member => {
+            const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+            const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(member.kind);
+            return handler.generateTypeKey(member);
+        });
+        return `[${memberTypeKeys.join(', ')}]`;
+    }
+    isOptionalOrNullablePattern() {
+        return this.supportedPattern === 'optional' ||
+            this.supportedPattern === 'nullable' ||
+            this.supportedPattern === 'optionalNullable';
+    }
+    getInnerMember(structure) {
+        switch (this.supportedPattern) {
+            case 'optional':
+                return structure.unionDetails?.find(m => m.kind !== Types_1.PropertyKind.UNDEFINED);
+            case 'nullable':
+                return structure.unionDetails?.find(m => m.kind !== Types_1.PropertyKind.NULL);
+            case 'optionalNullable':
+                return structure.unionDetails?.find(m => m.kind !== Types_1.PropertyKind.NULL && m.kind !== Types_1.PropertyKind.UNDEFINED);
+            default:
+                return undefined;
+        }
+    }
+    generateOptionalNullableInstantiation(structure) {
+        if (this.supportedPattern === 'optionalNullable' && structure.unionDetails?.length !== 3) {
+            throw new CustomError_1.CustomError(`${this.name}: expected 3 union members`, CustomError_1.ErrorCodes.UNION_EXPEDTED_THREE);
+        }
+        if (this.supportedPattern !== 'optionalNullable' && structure.unionDetails?.length !== 2) {
+            throw new CustomError_1.CustomError(`${this.name}: expected 2 union members`, CustomError_1.ErrorCodes.UNION_EXPEDTED_TWO);
+        }
+        const innerMember = this.getInnerMember(structure);
+        if (!innerMember) {
+            throw new CustomError_1.CustomError(`${this.name}: cannot find inner member`, CustomError_1.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})`;
+    }
+    generateOptionalNullableTypeKey(structure) {
+        const innerMember = this.getInnerMember(structure);
+        if (!innerMember) {
+            throw new CustomError_1.CustomError(`${this.name}: cannot find inner member`, CustomError_1.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_1.CustomError(`${this.name}: unsupported pattern`, CustomError_1.ErrorCodes.UNION_UNSUPPORTED_PATTERN);
+        }
+    }
+    parseUnionMembers(typeNode, context) {
+        const memberTypes = typeNode.getTypeNodes();
+        const members = [];
+        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;
+    }
+    generateSendableTypeDeclaration(structure) {
+        if (!structure.unionDetails || structure.unionDetails.length === 0) {
+            throw new CustomError_1.CustomError(`${this.name}: missing unionDetails for Sendable type declaration`, CustomError_1.ErrorCodes.UNION_STRUCTURE_NOT_FOUND);
+        }
+        const registry = require('./TypeHandlerRegistry').TypeHandlerRegistry.getInstance();
+        const sendableMemberTypes = structure.unionDetails.map(member => {
+            const handler = registry.getHandlerForKind(member.kind);
+            if (!handler) {
+                throw new CustomError_1.CustomError(`${this.name}: no handler for member type: ${member.kind}`, CustomError_1.ErrorCodes.HANDLER_NOT_FOUND);
+            }
+            return handler.generateSendableTypeDeclaration(member);
+        });
+        return sendableMemberTypes.join(' | ');
+    }
+    generatePropertyConversion(structure, sourceValue, direction) {
+        return sourceValue;
+    }
+}
+class NullableHandler extends UnionTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'NullableHandler';
+        this.kind = Types_1.PropertyKind.NULLABLE;
+        this.priority = 95;
+        this.supportedPattern = 'nullable';
+    }
+    getSerializerName() {
+        return 'NullableSerializer';
+    }
+}
+class OptionalHandler extends UnionTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'OptionalHandler';
+        this.kind = Types_1.PropertyKind.OPTIONAL;
+        this.priority = 95;
+        this.supportedPattern = 'optional';
+    }
+    getSerializerName() {
+        return 'OptionalSerializer';
+    }
+}
+class OptionalNullableHandler extends UnionTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'OptionalNullableHandler';
+        this.kind = Types_1.PropertyKind.OPTIONAL_NULLABLE;
+        this.priority = 95;
+        this.supportedPattern = 'optionalNullable';
+    }
+    getSerializerName() {
+        return 'OptionalNullableSerializer';
+    }
+}
+class UnionHandler extends UnionTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'UnionHandler';
+        this.kind = Types_1.PropertyKind.UNION;
+        this.priority = 85;
+        this.supportedPattern = 'union';
+    }
+    getSerializerName() {
+        return 'UnionTypeSerializer';
+    }
+}
+function createUnionTypeHandlers() {
+    return [
+        new OptionalHandler(),
+        new NullableHandler(),
+        new OptionalNullableHandler(),
+        new UnionHandler()
+    ];
+}

package/dist/core/handlers/index.d.ts

@@ -0,0 +1,2 @@
+export type { ITypeHandler, TypeContext } from './ITypeHandler';
+export { TypeHandlerRegistry } from './TypeHandlerRegistry';

package/dist/core/handlers/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeHandlerRegistry = void 0;
+var TypeHandlerRegistry_1 = require("./TypeHandlerRegistry");
+Object.defineProperty(exports, "TypeHandlerRegistry", { enumerable: true, get: function () { return TypeHandlerRegistry_1.TypeHandlerRegistry; } });

package/dist/core/import-rewrite/services/BuildProfileUpdater.d.ts

@@ -0,0 +1,8 @@
+import { ITargetContext } from '../../../json-plugin/interfaces/ITargetContext';
+export declare class BuildProfileUpdaterImpl {
+    updateSourceRoots(targetContext: ITargetContext): void;
+    private getModuleRootFromContext;
+    private readBuildProfile;
+    private writeBuildProfile;
+    private updateSourceRootsConfig;
+}