@lcap/asl/src/types/data/dataTypes.ts

NetEase Application Specific Language

import { Schema } from '..';
import { basicTypeMap, basicTypeList } from './basicTypes';
import { systemTypeList, systemTypeMap } from './systemTypes';
import { getGenericList } from './genericTypes';
import { cloneDeep } from 'lodash';

export const dataTypeList: Array<{
    title: string,
    children: Array<{ kind: string, text: string, value: string }>
}>
    = [
        { title: '基础类型', children: basicTypeList },
        { title: '自定义类型', children: [] },
        { title: '平台类型', children: systemTypeList },
    ];

export const dataTypesMap: { [name: string]: Schema } = {
    ...basicTypeMap,
    ...systemTypeMap,
};

export function updateDataTypeList() {
    dataTypeList[1].children = Object.keys(dataTypesMap)
        .filter((key) => !key.includes('#/basicTypes') && !key.includes('#/systemTypes') && !key.includes('#/genericTypes'))
        .map((key) => {
            const dataType = dataTypesMap[key];
            return { kind: (dataType as any).level, text: dataType.name, value: key };
        });
}

export function properties2PropertyList(definition: any) {
    if (!definition)
        return definition;

    definition = cloneDeep(definition);
    if (definition.properties) {
        const propertyList: any[] = definition.propertyList = [];
        Object.values(definition.properties).forEach((item) => {
            propertyList.push(properties2PropertyList(item));
        });
    }
    if (definition.items) {
        definition.items = properties2PropertyList(definition.items);
    }
    return definition;
}

export async function updateGenericTypeList() {
    const datatypes = await getGenericList();
    dataTypeList[2].children = datatypes.genericTypeList.concat(dataTypeList[2].children);
    Object.assign(dataTypesMap, datatypes.genericTypemap);
}

export function findDataTypeDescription(schema: Schema) {
    let i = 0;
    while (i < dataTypeList.length) {
        const dlist = dataTypeList[i];
        const finded = dlist.children.find((type) => type.value === schema.typeKey);
        if (finded) {
            return finded;
        }
        i++;
    }
}

export function isBasicType(schema: Schema) {
    return !!dataTypeList[0].children.find((type) => type.value === schema.typeKey);
}