static getPropEditorByUnionType()

in uui-build/ts/tasks/docsGen/converters/converterUtils/propEditorUtils.ts [74:144]
66 lines of code
15 McCabe index (conditional complexity)

    static getPropEditorByUnionType(unionType: Type): TPropEditor | undefined {
        const typeArr = unionType.getUnionTypes();
        let canBeNull = false;
        const arrNorm = typeArr.reduce<Type[]>((acc, ta) => {
            if (ta.isUndefined()) {
                return acc;
            } else if (ta.isNull()) {
                canBeNull = true;
                return acc;
            }
            acc.push(ta);
            return acc;
        }, []);

        if (arrNorm.length > 0) {
            const arrNormSplit = arrNorm.reduce<{
                scalars: (
                TPropEditorType.string | TPropEditorType.number
                )[],
                literals: Type[],
                etc: Type[]
            }>(
                    (acc, t) => {
                        if (t.isLiteral()) {
                            acc.literals.push(t);
                        } else if (t.isString()) {
                            acc.scalars.push(TPropEditorType.string);
                        } else if (t.isNumber()) {
                            acc.scalars.push(TPropEditorType.number);
                        } else {
                            acc.etc.push(t);
                        }
                        return acc;
                    },
                    { scalars: [], literals: [], etc: [] },
                    );

            const isMaybeOneOf = arrNormSplit.scalars.length <= 1 && arrNormSplit.literals.length > 0 && arrNormSplit.etc.length === 0;
            if (isMaybeOneOf) {
                if (
                    arrNormSplit.literals.length === 2
                    && arrNormSplit.literals[0].isBooleanLiteral()
                    && arrNormSplit.literals[1].isBooleanLiteral()
                ) {
                    return {
                        type: TPropEditorType.bool,
                    };
                }
                const options = arrNormSplit.literals.reduce<TOneOfItemType[]>((acc, t) => {
                    const v = PropEditorUtils.getLiteralValueFromType(t);
                    if (v !== undefined) {
                        acc.push(v);
                    }
                    return acc;
                }, []);
                if (canBeNull) {
                    options.push(null);
                }
                const res: TPropEditor = {
                    type: TPropEditorType.oneOf,
                    options: sortOptions(options),
                };
                if (arrNormSplit.scalars[0]) {
                    res.scalarTypeOption = arrNormSplit.scalars[0];
                }
                return res;
            } else if (arrNorm.length === 1) {
                return PropEditorUtils.getPropEditorByType(arrNorm[0]);
            }
        }
    }