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

package/dist/core/analyzers/CustomTypeAnalyzer.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomTypeAnalyzer = void 0;
+const __1 = require("..");
+const SerializationPathUtil_1 = __importDefault(require("../utils/SerializationPathUtil"));
+const TsMorphUtil_1 = require("../utils/TsMorphUtil");
+class CustomTypeAnalyzer {
+    constructor() {
+        this.searchCache = new Map();
+    }
+    static getInstance() {
+        return this.INSTANCE;
+    }
+    findDefinition(targetName, sourceFile) {
+        const cacheKey = `${sourceFile.getFilePath()}:${targetName}`;
+        if (cacheKey && this.searchCache.has(cacheKey)) {
+            const cached = this.searchCache.get(cacheKey);
+            return cached !== undefined ? cached : null;
+        }
+        let result;
+        result = this.findInCurrentFile(targetName, sourceFile);
+        if (result) {
+            if (cacheKey) {
+                this.searchCache.set(cacheKey, result);
+            }
+            return result;
+        }
+        result = this.findInImports(targetName, sourceFile);
+        if (result) {
+            if (cacheKey) {
+                this.searchCache.set(cacheKey, result);
+            }
+            return result;
+        }
+        result = this.findInCrossModule(targetName, sourceFile);
+        if (result) {
+            if (cacheKey) {
+                this.searchCache.set(cacheKey, result);
+            }
+            return result;
+        }
+        if (cacheKey) {
+            this.searchCache.set(cacheKey, null);
+        }
+        return null;
+    }
+    findClassDeclFromClassName(className, sourceFile) {
+        const res = this.findDefinition(className, sourceFile);
+        if (res && res.typeKind === __1.TypeKind.CLASS) {
+            return res.details.classDecl;
+        }
+        if (res && res.typeKind === __1.TypeKind.INTERFACE) {
+            return res.details.interfaceDecl;
+        }
+        return null;
+    }
+    clearCache() {
+        this.searchCache.clear();
+    }
+    findInCurrentFile(targetName, sourceFile) {
+        const typeDetail = this.searchInSourceFile(targetName, sourceFile);
+        if (typeDetail) {
+            return {
+                typeName: targetName,
+                typeKind: typeDetail.kind,
+                importPath: '',
+                source: {
+                    type: 'local',
+                    sourceFilePath: sourceFile.getFilePath()
+                },
+                details: typeDetail
+            };
+        }
+        return null;
+    }
+    findInImports(targetName, sourceFile) {
+        const imports = sourceFile.getImportDeclarations();
+        for (const importDecl of imports) {
+            const namedImports = importDecl.getNamedImports();
+            const specifierValue = importDecl.getModuleSpecifierValue();
+            for (const namedImport of namedImports) {
+                const importName = namedImport.getName();
+                if (importName === targetName) {
+                    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+                    const resolvedPath = this.resolveImportPath(moduleSpecifier, sourceFile);
+                    if (resolvedPath && SerializationPathUtil_1.default.exist(resolvedPath)) {
+                        const externalSourceFile = this.getOrLoadSourceFile(resolvedPath);
+                        if (externalSourceFile) {
+                            const typeDetail = this.searchInSourceFile(targetName, externalSourceFile);
+                            if (typeDetail) {
+                                return {
+                                    typeName: targetName,
+                                    typeKind: typeDetail.kind,
+                                    importPath: specifierValue,
+                                    source: {
+                                        type: 'imported',
+                                        sourceFilePath: externalSourceFile.getFilePath(),
+                                        originalImport: specifierValue
+                                    },
+                                    details: typeDetail
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    findInCrossModule(targetName, sourceFile) {
+        return null;
+    }
+    searchInSourceFile(targetName, sourceFile) {
+        const classes = sourceFile.getClasses();
+        for (const classDecl of classes) {
+            if (classDecl.getName() === targetName) {
+                return this.parseClassDetails(classDecl);
+            }
+        }
+        const interfaces = sourceFile.getInterfaces();
+        for (const interfaceDecl of interfaces) {
+            if (interfaceDecl.getName() === targetName) {
+                return this.parseInterfaceDetails(interfaceDecl);
+            }
+        }
+        const enums = sourceFile.getEnums();
+        for (const enumDecl of enums) {
+            if (enumDecl.getName() === targetName) {
+                return this.parseEnumDetails(enumDecl);
+            }
+        }
+        const types = sourceFile.getTypeAliases();
+        for (const typeAliasDecl of types) {
+            if (typeAliasDecl.getName() === targetName) {
+                return this.parseTypeAliasDetails(typeAliasDecl);
+            }
+        }
+        return null;
+    }
+    parseEnumDetails(enumDecl) {
+        const members = [];
+        let valueType = 'number';
+        let numericValue = 0;
+        const enumMembers = enumDecl.getMembers();
+        for (const member of enumMembers) {
+            const memberName = member.getName();
+            let memberValue;
+            let literalValue;
+            const initializer = member.getInitializer();
+            if (initializer) {
+                const initText = initializer.getText().trim();
+                if (initText.startsWith('"') && initText.endsWith('"')) {
+                    memberValue = initText.slice(1, -1);
+                    literalValue = initText;
+                    valueType = 'string';
+                }
+                else if (initText.startsWith("'") && initText.endsWith("'")) {
+                    memberValue = initText.slice(1, -1);
+                    literalValue = `"${memberValue}"`;
+                    valueType = 'string';
+                }
+                else {
+                    const numValue = parseInt(initText, 10);
+                    if (!isNaN(numValue)) {
+                        memberValue = numValue;
+                        literalValue = numValue.toString();
+                        numericValue = numValue + 1;
+                    }
+                    else {
+                        memberValue = initText;
+                        literalValue = `"${initText}"`;
+                        valueType = 'string';
+                    }
+                }
+            }
+            else {
+                memberValue = numericValue;
+                literalValue = numericValue.toString();
+                numericValue++;
+            }
+            members.push({
+                name: memberName,
+                value: memberValue,
+                literalValue
+            });
+        }
+        return { kind: __1.TypeKind.ENUM, valueType, members };
+    }
+    parseClassDetails(classDecl) {
+        return {
+            kind: __1.TypeKind.CLASS,
+            classDecl,
+            isGeneric: classDecl.getTypeParameters().length > 0
+        };
+    }
+    parseInterfaceDetails(interfaceDecl) {
+        return {
+            kind: __1.TypeKind.INTERFACE,
+            interfaceDecl,
+            isGeneric: interfaceDecl.getTypeParameters().length > 0
+        };
+    }
+    parseTypeAliasDetails(typeAliasDecl) {
+        const aliasedType = typeAliasDecl.getTypeNodeOrThrow().getText();
+        const actualTypeNode = typeAliasDecl.getTypeNodeOrThrow();
+        const { TypeHandlerRegistry } = require('../handlers/TypeHandlerRegistry');
+        const resolvedType = TypeHandlerRegistry.getInstance().parseType(actualTypeNode, {
+            depth: 0,
+            genericParams: []
+        });
+        return { kind: __1.TypeKind.TYPE, aliasedType, resolvedType };
+    }
+    resolveImportPath(moduleSpecifier, sourceFile) {
+        const currentFilePath = sourceFile.getFilePath();
+        const currentDir = SerializationPathUtil_1.default.dirname(currentFilePath);
+        if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
+            const resolvedPath = SerializationPathUtil_1.default.pathResolve(currentDir, moduleSpecifier);
+            const extensions = ['.ets', '.d.ets'];
+            for (const ext of extensions) {
+                const fullPath = resolvedPath + ext;
+                if (SerializationPathUtil_1.default.exist(fullPath)) {
+                    return fullPath;
+                }
+            }
+        }
+        return null;
+    }
+    getOrLoadSourceFile(filePath) {
+        const existingFile = TsMorphUtil_1.TsMorphUtil.getProject().getSourceFile(filePath);
+        if (existingFile) {
+            return existingFile;
+        }
+        if (SerializationPathUtil_1.default.exist(filePath)) {
+            return TsMorphUtil_1.TsMorphUtil.getProject().addSourceFileAtPath(filePath);
+        }
+        return null;
+    }
+}
+exports.CustomTypeAnalyzer = CustomTypeAnalyzer;
+CustomTypeAnalyzer.INSTANCE = new CustomTypeAnalyzer();

package/dist/core/analyzers/SendableMergeChecker.d.ts

@@ -0,0 +1,9 @@
+import { ClassAnalysis } from '../Types';
+export declare class SendableMergeChecker {
+    private static readonly TURBO_TRANS_DECORATORS;
+    private static readonly SENDABLE_PRIMITIVE_KINDS;
+    private static readonly SENDABLE_COLLECTION_KINDS;
+    static check(classAnalysis: ClassAnalysis): boolean;
+    private static getNonTurboTransDecorators;
+    private static isSendableType;
+}

package/dist/core/analyzers/SendableMergeChecker.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendableMergeChecker = void 0;
+const Types_1 = require("../Types");
+const constants_1 = require("../constants");
+const Logger_1 = require("../logger/Logger");
+const SendableMergeabilityRegistry_1 = require("./SendableMergeabilityRegistry");
+class SendableMergeChecker {
+    static check(classAnalysis) {
+        const classDecorators = classAnalysis.originalClass?.getDecorators() || [];
+        const nonTurboTransDecorators = this.getNonTurboTransDecorators(classDecorators);
+        if (nonTurboTransDecorators.length > 0) {
+            Logger_1.Logger.debug(`${classAnalysis.className}类有其他装饰器`);
+            return false;
+        }
+        if (classAnalysis.generics.isGeneric) {
+            Logger_1.Logger.debug(`${classAnalysis.className}类有泛型参数`);
+            return false;
+        }
+        const invalidProperties = [];
+        for (const property of classAnalysis.properties) {
+            const propertyNode = classAnalysis.originalClass?.getProperty(property.name);
+            if (propertyNode) {
+                const propDecorators = propertyNode.getDecorators();
+                const nonTurboPropDecorators = this.getNonTurboTransDecorators(propDecorators);
+                if (nonTurboPropDecorators.length > 0) {
+                    invalidProperties.push(`${property.name} (装饰器: ${nonTurboPropDecorators.join(', ')})`);
+                    continue;
+                }
+            }
+            if (!this.isSendableType(property.type, classAnalysis)) {
+                invalidProperties.push(`${property.name} (类型: ${property.type.sourceText})`);
+            }
+        }
+        if (classAnalysis.originalClass) {
+            for (const method of classAnalysis.originalClass.getMethods()) {
+                const methodDecorators = method.getDecorators();
+                const nonTurboPropDecorators = this.getNonTurboTransDecorators(methodDecorators);
+                if (nonTurboPropDecorators.length > 0) {
+                    invalidProperties.push(`${method.getName()} (装饰器: ${nonTurboPropDecorators.join(', ')})`);
+                }
+            }
+        }
+        if (invalidProperties.length > 0) {
+            Logger_1.Logger.debug(invalidProperties.join('\n'));
+            return false;
+        }
+        if (classAnalysis.inheritance.isInherited && classAnalysis.inheritance.baseClassAnalysis) {
+            Logger_1.Logger.debug(`${classAnalysis.className}的父类不可合并`);
+            return this.check(classAnalysis.inheritance.baseClassAnalysis);
+        }
+        return true;
+    }
+    static getNonTurboTransDecorators(decorators) {
+        return decorators
+            .map(d => d.getName())
+            .filter(name => !this.TURBO_TRANS_DECORATORS.has(name));
+    }
+    static isSendableType(typeStructure, contextClass) {
+        const { kind } = typeStructure;
+        if (this.SENDABLE_PRIMITIVE_KINDS.has(kind)) {
+            return true;
+        }
+        if (this.SENDABLE_COLLECTION_KINDS.has(kind)) {
+            return typeStructure.args.every(arg => this.isSendableType(arg, contextClass));
+        }
+        if (kind === Types_1.PropertyKind.OBJECT && typeStructure.classDetails) {
+            const classDetails = typeStructure.classDetails;
+            if (classDetails.classDecl.getDecorator('Sendable')) {
+                return true;
+            }
+            const className = classDetails.classDecl.getNameOrThrow();
+            const canMerge = SendableMergeabilityRegistry_1.SendableMergeabilityRegistry.canMerge(className);
+            if (canMerge === undefined) {
+                return false;
+            }
+            return canMerge;
+        }
+        if ((kind === Types_1.PropertyKind.UNION || kind === Types_1.PropertyKind.OPTIONAL || kind === Types_1.PropertyKind.NULLABLE) &&
+            typeStructure.unionDetails) {
+            return typeStructure.unionDetails.every(member => this.isSendableType(member, contextClass));
+        }
+        return false;
+    }
+}
+exports.SendableMergeChecker = SendableMergeChecker;
+SendableMergeChecker.TURBO_TRANS_DECORATORS = new Set(constants_1.DecoratorConstants.SERIAL_DECORATORS);
+SendableMergeChecker.SENDABLE_PRIMITIVE_KINDS = new Set([
+    Types_1.PropertyKind.STRING,
+    Types_1.PropertyKind.NUMBER,
+    Types_1.PropertyKind.BOOLEAN,
+    Types_1.PropertyKind.BIGINT,
+    Types_1.PropertyKind.NULL,
+    Types_1.PropertyKind.UNDEFINED,
+]);
+SendableMergeChecker.SENDABLE_COLLECTION_KINDS = new Set([
+    Types_1.PropertyKind.COLLECTIONS_ARRAY,
+    Types_1.PropertyKind.COLLECTIONS_SET,
+    Types_1.PropertyKind.COLLECTIONS_MAP,
+]);

package/dist/core/analyzers/SendableMergeabilityRegistry.d.ts

@@ -0,0 +1,7 @@
+export declare class SendableMergeabilityRegistry {
+    private static mergeabilityMap;
+    static register(className: string, canMerge: boolean): void;
+    static canMerge(className: string): boolean | undefined;
+    static hasClass(className: string): boolean;
+    static clear(): void;
+}

package/dist/core/analyzers/SendableMergeabilityRegistry.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendableMergeabilityRegistry = void 0;
+const __1 = require("..");
+class SendableMergeabilityRegistry {
+    static register(className, canMerge) {
+        this.mergeabilityMap.set(className, canMerge);
+        __1.Logger.debug(`[SendableMergeabilityRegistry] 注册类合并性: ${className} -> ${canMerge}`);
+    }
+    static canMerge(className) {
+        return this.mergeabilityMap.get(className);
+    }
+    static hasClass(className) {
+        return this.mergeabilityMap.has(className);
+    }
+    static clear() {
+        const count = this.mergeabilityMap.size;
+        this.mergeabilityMap.clear();
+        __1.Logger.debug(`[SendableMergeabilityRegistry] 清空注册表，已移除 ${count} 个类的合并性信息`);
+    }
+}
+exports.SendableMergeabilityRegistry = SendableMergeabilityRegistry;
+SendableMergeabilityRegistry.mergeabilityMap = new Map();

package/dist/core/constants/DecoratorConstants.d.ts

@@ -0,0 +1,7 @@
+export declare class DecoratorConstants {
+    static readonly SERIALIZABLE = "Serializable";
+    static readonly SERIAL_NAME = "SerialName";
+    static readonly REQUIRED = "Required";
+    static readonly TRANSIENT = "Transient";
+    static readonly SERIAL_DECORATORS: string[];
+}

package/dist/core/constants/DecoratorConstants.js

@@ -0,0 +1,13 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecoratorConstants = void 0;
+class DecoratorConstants {
+}
+exports.DecoratorConstants = DecoratorConstants;
+_a = DecoratorConstants;
+DecoratorConstants.SERIALIZABLE = 'Serializable';
+DecoratorConstants.SERIAL_NAME = 'SerialName';
+DecoratorConstants.REQUIRED = 'Required';
+DecoratorConstants.TRANSIENT = 'Transient';
+DecoratorConstants.SERIAL_DECORATORS = [_a.SERIALIZABLE, _a.SERIAL_NAME, _a.REQUIRED, _a.TRANSIENT];

package/dist/core/constants/PathConstants.d.ts

@@ -0,0 +1,6 @@
+export declare class PathConstants {
+    static readonly DEFAULT_SOURCE_ROOT = "./src/main";
+    static readonly GENERATED_ROOT = "./src/generated";
+    static readonly ETS_EXTENSIONS = ".ets";
+    static readonly DEFAULT_SCAN_DIRS: string[];
+}

package/dist/core/constants/PathConstants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathConstants = void 0;
+class PathConstants {
+}
+exports.PathConstants = PathConstants;
+PathConstants.DEFAULT_SOURCE_ROOT = './src/main';
+PathConstants.GENERATED_ROOT = './src/generated';
+PathConstants.ETS_EXTENSIONS = '.ets';
+PathConstants.DEFAULT_SCAN_DIRS = ['src/main/ets'];

package/dist/core/constants/StringConstants.d.ts

@@ -0,0 +1,83 @@
+export declare 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";
+    static readonly BOOLEAN_SERIALIZER = "BooleanSerializer";
+    static readonly NUMBER_SERIALIZER = "NumberSerializer";
+    static readonly STRING_SERIALIZER = "StringSerializer";
+    static readonly BIGINT_SERIALIZER = "BigintSerializer";
+    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: RegExp;
+    static readonly REGEX_SRC_MAIN_ETS: RegExp;
+    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/dist/core/constants/StringConstants.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringConstants = void 0;
+class StringConstants {
+}
+exports.StringConstants = StringConstants;
+StringConstants.TYPE_BOOLEAN = 'boolean';
+StringConstants.TYPE_NUMBER = 'number';
+StringConstants.TYPE_STRING = 'string';
+StringConstants.TYPE_BIGINT = 'bigint';
+StringConstants.TYPE_NULL = 'null';
+StringConstants.TYPE_UNDEFINED = 'undefined';
+StringConstants.TYPE_ARRAY = 'array';
+StringConstants.TYPE_SET = 'set';
+StringConstants.TYPE_MAP = 'map';
+StringConstants.TYPE_UNION = 'union';
+StringConstants.TYPE_ENUM = 'enum';
+StringConstants.BOOLEAN_SERIALIZER = 'BooleanSerializer';
+StringConstants.NUMBER_SERIALIZER = 'NumberSerializer';
+StringConstants.STRING_SERIALIZER = 'StringSerializer';
+StringConstants.BIGINT_SERIALIZER = 'BigintSerializer';
+StringConstants.NULL_SERIALIZER = 'NullSerializer';
+StringConstants.UNDEFINED_SERIALIZER = 'UndefinedSerializer';
+StringConstants.ARRAY_SERIALIZER = 'ArraySerializer';
+StringConstants.COLLECTIONS_ARRAY_SERIALIZER = 'CollectionsArraySerializer';
+StringConstants.MAP_SERIALIZER = 'MapSerializer';
+StringConstants.COLLECTIONS_MAP_SERIALIZER = 'CollectionsMapSerializer';
+StringConstants.SET_SERIALIZER = 'SetSerializer';
+StringConstants.COLLECTIONS_SET_SERIALIZER = 'CollectionsSetSerializer';
+StringConstants.RECORD_SERIALIZER = 'RecordSerializer';
+StringConstants.UNION_TYPE_SERIALIZER = 'UnionTypeSerializer';
+StringConstants.OPTIONAL_SERIALIZER = 'OptionalSerializer';
+StringConstants.NULLABLE_SERIALIZER = 'NullableSerializer';
+StringConstants.ENUM_SERIALIZER = 'EnumSerializer';
+StringConstants.SERIALIZER = 'Serializer';
+StringConstants.SERIALIZER_FACTORY = 'SerializerFactory';
+StringConstants.ENCODE_BOOLEAN_ELEMENT = 'encodeBooleanElement';
+StringConstants.ENCODE_NUMBER_ELEMENT = 'encodeNumberElement';
+StringConstants.ENCODE_STRING_ELEMENT = 'encodeStringElement';
+StringConstants.ENCODE_BIGINT_ELEMENT = 'encodeBigintElement';
+StringConstants.ENCODE_NULL_ELEMENT = 'encodeNullElement';
+StringConstants.ENCODE_UNDEFINED_ELEMENT = 'encodeUndefinedElement';
+StringConstants.ENCODE_SERIALIZABLE_ELEMENT = 'encodeSerializableElement';
+StringConstants.DECODE_BOOLEAN = 'decodeBoolean';
+StringConstants.DECODE_NUMBER = 'decodeNumber';
+StringConstants.DECODE_STRING = 'decodeString';
+StringConstants.DECODE_BIGINT = 'decodeBigint';
+StringConstants.DECODE_NULL = 'decodeNull';
+StringConstants.DECODE_UNDEFINED = 'decodeUndefined';
+StringConstants.DESERIALIZABLE = 'deserialize';
+StringConstants.IMPORT_BUILD_CLASS_SERIAL_DESCRIPTOR = 'buildClassSerialDescriptor';
+StringConstants.IMPORT_DECODER = 'Decoder';
+StringConstants.IMPORT_ENCODER = 'Encoder';
+StringConstants.IMPORT_SERIAL_DESCRIPTOR = 'SerialDescriptor';
+StringConstants.IMPORT_SERIALIZER = 'Serializer';
+StringConstants.IMPORT_TJSON = 'TJSON';
+StringConstants.IMPORT_IT_SERIALIZABLE = 'ITSerializable';
+StringConstants.IMPORT_LANG = 'lang';
+StringConstants.BOOLEAN_WRAPPER = 'Boolean';
+StringConstants.NUMBER_WRAPPER = 'Number';
+StringConstants.STRING_WRAPPER = 'String';
+StringConstants.ARRAY_SUFFIX = '[]';
+StringConstants.ARRAY_PREFIX = 'array<';
+StringConstants.DEFAULT_VALUE_FALSE = 'false';
+StringConstants.DEFAULT_VALUE_ZERO = '0';
+StringConstants.DEFAULT_VALUE_EMPTY_STRING = "''";
+StringConstants.DEFAULT_VALUE_ZERO_BIGINT = '0n';
+StringConstants.DEFAULT_VALUE_UNDEFINED = 'undefined';
+StringConstants.TEMPLATE_ELEMENT_NAME = 'element';
+StringConstants.TEMPLATE_SENDABLE_ERROR_PREFIX = 'Sendable support not enabled for';
+StringConstants.FILE_OPERATION_EMPTY_STRING = '';
+StringConstants.REGEX_IMPORT_STATEMENT = /import\s+({[^}]+}|\w+)\s+from\s+'([^']+)'/;
+StringConstants.REGEX_SRC_MAIN_ETS = /\/src\/main\/ets\/(.*)\.ets$/;
+StringConstants.SEPARATOR_COMMA = ',';
+StringConstants.SEPARATOR_COMMA_NEWLINE = ',\n';
+StringConstants.SEPARATOR_NEWLINE = '\n';
+StringConstants.SEPARATOR_COMMA_SPACE = ', ';
+StringConstants.JOIN_ELEMENT_PREFIX = ',\n  ';
+StringConstants.CURLY_BRACE_START = '{';
+StringConstants.PATH_RELATIVE_PREFIX = './';
+StringConstants.INSTANCE_SUFFIX = '.INSTANCE';
+StringConstants.SERIALIZER_SUFFIX = 'Serializer';
+StringConstants.LOG_PREFIX_T_SERIALIZATION = '[TSerialization]';
+StringConstants.LOG_MODULE_PREFIX_TEMPLATE = '[${module}]';
+StringConstants.PLUGIN_ID = 'turboTransJsonPlugin';
+StringConstants.JSON_MODULE_SPECIFIER = '@hadss/hmserialization-json';
+StringConstants.ARKTS_MODULE_SPECIFIER = '@kit.ArkTS';

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

@@ -0,0 +1,3 @@
+export * from './StringConstants';
+export * from './DecoratorConstants';
+export * from './PathConstants';

package/dist/core/constants/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./StringConstants"), exports);
+__exportStar(require("./DecoratorConstants"), exports);
+__exportStar(require("./PathConstants"), exports);

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

@@ -0,0 +1,23 @@
+import { TypeNode } from 'ts-morph';
+import { ITypeHandler, TypeContext, ConversionDirection } from './ITypeHandler';
+import { PropertyKind, SerializerMetadata, TypeStructure } from '../Types';
+export declare 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;
+    protected getSerializerName(): string;
+    protected getTypeName(): string;
+    protected capitalize(str: string): string;
+    protected applyWithParam(withParam: string | undefined, defaultInstantiation: string, structure: TypeStructure): string;
+    protected containsGenericType(structure: TypeStructure): boolean;
+    protected generateTypeKeySerializers(structure: TypeStructure): string;
+    protected generateTypeKeys(structure: TypeStructure): string;
+}