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

NetEase Application Specific Language

import { genericService } from '../../service/data';
import { utils } from '..';
import { convert2RefType } from './dataTypeUtils';

export function getGenericTypeRef(typeName: string) {
    return `#/genericTypes/${typeName}`;
}

export async function getGenericList() {
    let list = [];
    try {
        list = await genericService.getGenericClassList();
    } catch (err) { }
    const genericTypeList: any = [];
    const genericTypemap: any = {};
    if (list) {
        list.forEach((item: any) => {
            const tempItem = Object.assign({}, item);
            utils.traverse((current) => {
                if (
                    current.node.type === 'genericType'
                    || current.node.format !== undefined
                ) {
                    convert2RefType(current.node);
                }
            }, {
                node: tempItem,
            }, {
                mode: 'anyObject',
            });
            genericTypemap[`#/genericTypes/${tempItem.name}`] = tempItem;
            const listItem = {
                kind: 'genericType',
                type: 'genericType',
                text: `${item.name}<${(item.typeParams || []).map((param: any) => param.typeParamName).join(',')}>`,
                value: `#/genericTypes/${tempItem.name}`,
                typeInstantiation: {
                    typeName: item.name,
                    typeParams: (item.typeParams || []).map((param: any) => Object.assign({ typeParamValue: '' }, param)),
                },
            };
            genericTypeList.push(listItem);
        });
    }
    return {
        genericTypeList,
        genericTypemap,
    };
}

export const genericTypeList = [
    {
        level: 'structure',
        name: 'PageOf',
        type: 'genericClass',
        typeParams: [
            { type: 'typeParam', typeParamName: 'T' },
        ],
        propertyList: [
            {
                level: 'property',
                name: 'content',
                type: 'genericType',
                typeKey: '#/genericTypes/List',
                typeInstantiation: {
                    typeName: 'List',
                    typeParams: [
                        {
                            level: 'typeParam',
                            typeParamName: 'V',
                            typeParamValue:
                            {
                                type: 'genericParam',
                                typeParamName: 'T',
                            },
                        },
                    ],
                },
            },
            { name: 'number', type: 'integer' },
            { name: 'size', type: 'integer' },
            { name: 'totalPages', type: 'integer' },
            { name: 'totalElements', type: 'integer' },
        ],
    },
];

export const genericTypeMap: { [name: string]: any } = {
    '#/genericTypes/PageOf': {
        name: 'PageOf',
        type: 'genericClass',
        typeParams: [
            { type: 'typeParam', typeParamName: 'T' },
        ],
        propertyList: [
            {
                level: 'property',
                name: 'content',
                type: 'genericType',
                typeKey: '#/genericTypes/List', //获取数据后要处理一下，加上typeKey字段
                typeInstantiation: {
                    typeName: 'List',
                    typeParams: [
                        {
                            level: 'typeParam',
                            typeParamName: 'V',
                            typeParamValue:
                            {
                                type: 'genericParam',
                                typeParamName: 'T',
                            },
                        },
                    ],
                },
            },
            { name: 'number', type: 'integer' },
            { name: 'size', type: 'integer' },
            { name: 'totalPages', type: 'integer' },
            { name: 'totalElements', type: 'integer' },
        ],
    },
    '#/genericTypes/ScopeOf': {
        name: 'ScopeOf',
        type: 'genericClass',
        typeParams: [
            { type: 'typeParam', typeParamName: 'T' },
        ],
        propertyList: [
            { name: 'item', type: 'genericParam', typeParamName: 'T' },
            { name: 'index', type: 'integer' },
            { name: 'rowIndex', type: 'integer' },
            { name: 'columnIndex', type: 'integer' },
            { name: 'value', type: 'string' },

        ],
    },
    '#/genericTypes/List': {
        name: 'List',
        type: 'genericClass',
        typeParams: [
            { type: 'typeParam', typeParamName: 'T' },
        ],
        propertyList: [
            { name: 'length', type: 'integer' },
        ],
    },
};