= (props: TypeProps): any => {
const type = props.type;
const isReference = type.typeDocType === TypeDocTypes.Reference;
const isArray = type.typeDocType === TypeDocTypes.Array;
let typeNameColor = 'inherit';
let typeName: string | React.ReactNode;
let typeArgs: React.ReactNode[] = [];
switch (type.typeDocType) {
case TypeDocTypes.Intrinsic:
case TypeDocTypes.Unknown:
typeName = type.name;
typeNameColor = colors.orange;
break;
case TypeDocTypes.Reference:
typeName = type.name;
typeArgs = _.map(type.typeArguments, (arg: TypeDef) => {
if (arg.typeDocType === TypeDocTypes.Array) {
const key = `type-${arg.elementType.name}-${arg.elementType.typeDocType}`;
return (
[]
);
} else {
const subType = (
);
return subType;
}
});
break;
case TypeDocTypes.StringLiteral:
typeName = `'${type.value}'`;
typeNameColor = colors.green;
break;
case TypeDocTypes.Array:
typeName = type.elementType.name;
if (_.includes(basicJsTypes, typeName) || _.includes(basicSolidityTypes, typeName)) {
typeNameColor = colors.orange;
}
break;
case TypeDocTypes.Union:
const unionTypes = _.map(type.types, t => {
return (
);
});
typeName = _.reduce(unionTypes, (prev: React.ReactNode, curr: React.ReactNode) => {
return [prev, '|', curr];
});
break;
case TypeDocTypes.Reflection:
if (!_.isUndefined(type.method)) {
typeName = (
);
} else if (!_.isUndefined(type.indexSignature)) {
const is = type.indexSignature;
const param = (
{is.keyName}:{' '}
);
typeName = (
{'{'}[{param}]: {is.valueName}
{'}'}
);
} else {
throw new Error(`Unrecognized Reflection type that isn't a Method nor an Index Signature`);
}
break;
case TypeDocTypes.TypeParameter:
typeName = type.name;
break;
case TypeDocTypes.Intersection:
const intersectionsTypes = _.map(type.types, t => {
return (
);
});
typeName = _.reduce(intersectionsTypes, (prev: React.ReactNode, curr: React.ReactNode) => {
return [prev, '&', curr];
});
break;
case TypeDocTypes.Tuple:
const tupleTypes = _.map(type.tupleElements, (t, i) => {
return (
);
});
typeName = (
[{_.reduce(tupleTypes, (prev: React.ReactNode, curr: React.ReactNode) => {
return [prev, ', ', curr];
})}]
);
break;
default:
throw errorUtils.spawnSwitchErr('type.typeDocType', type.typeDocType);
}
// HACK: Normalize BigNumber to simply BigNumber. For some reason the type
// name is unpredictably one or the other.
if (typeName === 'BigNumber') {
typeName = 'BigNumber';
}
const commaSeparatedTypeArgs = _.reduce(typeArgs, (prev: React.ReactNode, curr: React.ReactNode) => {
return [prev, ', ', curr];
});
const isExportedClassReference = !!props.type.isExportedClassReference;
const typeNameUrlIfExists = !_.isUndefined(props.type.externalLink) ? props.type.externalLink : undefined;
if (!_.isUndefined(typeNameUrlIfExists)) {
typeName = props.isInPopover ? (
{typeName}
) : (
{typeName}
);
} else if (
(isReference || isArray) &&
((props.typeDefinitionByName && props.typeDefinitionByName[typeName as string]) || isExportedClassReference)
) {
const id = Math.random().toString();
const typeDefinitionAnchorId = isExportedClassReference
? props.type.name
: `${props.docsInfo.typeSectionName}-${typeName}`;
typeName = (
{sharedUtils.isUserOnMobile() || props.isInPopover || isExportedClassReference ? (
{typeName}
) : (
{typeName}
)}
);
}
return (
{typeName}
{isArray && '[]'}
{!_.isEmpty(typeArgs) && (
{'<'}
{commaSeparatedTypeArgs}
{'>'}
)}
);
};
Type.defaultProps = defaultProps;