KnitFlow/assets/scripts/uitl/baseData/myUtil/saveCompoent/annotation/GlobalSaveDataImpl.ts

import { Bean } from "../../Bean/Bean"
import { GlobalSaveData, SaveInterface } from "./DataAnnotation"
type Constructor<T = unknown> = new (...args: any[]) => T
@Bean(GlobalSaveData, 'FRAMEWORK')
class GlobalSaveDataImpl extends GlobalSaveData {
    serialize<T>(serializeData: T, key?: Constructor<T>): Object {
        let res = {}
        if (!serializeData) {
            return null
        }
        // 获取该类的构造器
        let constructor = key || (serializeData as any)?.constructor
        if (getClassInheritanceLevel(constructor, SaveInterface)) {
            return (serializeData as SaveInterface).serialize()
        }

        // 如果不是定义的序列化类，则不需要序列化
        if (!this.isCompoent(constructor)) {
            return null
        }
        // 获取需要序列化的属性
        let values = this.getPropMap().get(constructor)

        values.forEach((v, k: string) => {
            let serializeName = v.serializeName
            // 获取该类的属性值
            let porpValue = serializeData[k]
            let data = this.getObj(v.constructor, porpValue)
            res[serializeName] = data
        })
        return res
    }
    unserialize<T>(key: Constructor<T>, saveData: any): T {
        if (!key) {
            return null
        }

        let component = new key
        if (getClassInheritanceLevel(key, SaveInterface)) {
            return (component as SaveInterface).unserialize(saveData) as T
        }

        saveData = saveData || {}
        // 获取需要反序列化的属性
        let values = this.getPropMap().get(key)
        if (!values) {
            return component
        }
        // 给属性赋值
        values.forEach((v, k: string) => {
            let data = this.getData(v.constructor, saveData[v.serializeName])
            if (data == null) {
                let defaultValue = null
                if (typeof v.defaultValue == 'function') {
                    defaultValue = v.defaultValue()
                } else {
                    defaultValue = v.defaultValue
                }
                component[k] = defaultValue
                return
            }
            component[k] = data
        })
        return component
    }

    /**
     * 将任意值转换为指定类型
     * @param type value 输入值
     * @param vlaue 转换后的值或null
     * @returns 
     */
    getData(type: Constructor, vlaue: any) {
        let v = vlaue ?? null

        // 先判断特殊类的处理方式
        if (this.isCompoent(type) || getClassInheritanceLevel(type, SaveInterface)) {
            return this.unserialize(type, vlaue)
        }
        if (v == null) {
            return null
        }

        if (type instanceof Map) {
            let map = new Map
            Object.keys(v).forEach((k) => {
                map.set(k, v[k])
            })
            return map
        } else if (type instanceof Set) {
            return new Set(v)
        } else if (type instanceof Array) {
            return JSON.parse(vlaue)
        } else {
            // 如果都不是默认为基本数据类型
            return vlaue
        }
    }

    /**
     * 将任意类型序列化为{}
     * @param type value 输入值
     * @param vlaue 转换后的值或null
     * @returns 
     */
    getObj<T>(type: Constructor<T>, vlaue: T) {
        let v = vlaue ?? null
        // 先判断特殊类的处理方式
        if (this.isCompoent(type) || getClassInheritanceLevel(type, SaveInterface)) {
            return this.serialize(vlaue, type)
        }
        if (v == null) {
            return null
        }

        if (type instanceof Map) {
            return JSON.stringify(vlaue)
        } else if (type instanceof Set) {
            return JSON.stringify(vlaue)

        } else if (type instanceof Array) {
            return JSON.stringify(vlaue)
        } else {
            // 如果都不是默认为基本数据类型
            return vlaue
        }

    }
}

/**
 * 判断类 subClass 是否是类 superClass 的第 n 级子类
 * @param subClass 子类构造函数
 * @param superClass 父类构造函数
 * @returns 继承层级（1表示直接子类），未继承返回 -1
 */
function getClassInheritanceLevel(subClass: Function, superClass: Function): boolean {
    if (typeof subClass !== 'function' || typeof superClass !== 'function') return false;

    return subClass['spuerTop'] == superClass['spuerTop']
    // return -1;
}