private static getCustomSymbolType()

in src/EnhancedScatterChart.ts [441:538]
72 lines of code
9 McCabe index (conditional complexity)

    private static getCustomSymbolType(shape: any): ShapeFunction {
        const customSymbolTypes = d3.map<ShapeFunction>({
            "circle": (size: number) => {
                const r: number = Math.sqrt(size / Math.PI);

                return `M0,${r}A${r},${r} 0 1,1 0,${-r}A${r},${r} 0 1,1 0,${r}Z`;
            },

            "cross": (size: number) => {
                const r: number = Math.sqrt(size / EnhancedScatterChart.R5) / EnhancedScatterChart.R2;

                return `M${-EnhancedScatterChart.R3 * r},${-r}H${-r}V${-EnhancedScatterChart.R3 * r}H${r}V${-r}H${EnhancedScatterChart.R3 * r}V${r}H${r}V${EnhancedScatterChart.R3 * r}H${-r}V${r}H${-EnhancedScatterChart.R3 * r}Z`;
            },

            "diamond": (size: number) => {
                const ry: number = Math.sqrt(size / (EnhancedScatterChart.R2 * Math.tan(Math.PI / EnhancedScatterChart.R6))),
                    rx: number = ry * Math.tan(Math.PI / EnhancedScatterChart.R6);

                return `M0,${-ry}L${rx},0 0,${ry} ${-rx},0Z`;
            },

            "square": (size: number) => {
                const r: number = Math.sqrt(size) / EnhancedScatterChart.R2;

                return `M${-r},${-r}L${r},${-r} ${r},${r} ${-r},${r}Z`;
            },

            "triangle-up": (size: number) => {
                const rx: number = Math.sqrt(size / Math.sqrt(EnhancedScatterChart.R3)),
                    ry: number = rx * Math.sqrt(EnhancedScatterChart.R3) / EnhancedScatterChart.R2;

                return `M0,${-ry}L${rx},${ry} ${-rx},${ry}Z`;
            },

            "triangle-down": (size: number) => {
                const rx: number = Math.sqrt(size / Math.sqrt(EnhancedScatterChart.R3)),
                    ry: number = rx * Math.sqrt(EnhancedScatterChart.R3) / EnhancedScatterChart.R2;

                return `M0,${ry}L${rx},${-ry} ${-rx},${-ry}Z`;
            },

            "star": (size: number) => {
                const outerRadius: number = Math.sqrt(size / EnhancedScatterChart.R2),
                    innerRadius: number = Math.sqrt(size / EnhancedScatterChart.R10),
                    angle: number = Math.PI / EnhancedScatterChart.R5;

                let results: string = "";
                for (let i: number = 0; i < EnhancedScatterChart.R10; i++) {
                    // Use outer or inner radius depending on what iteration we are in.
                    const r: number = (i & EnhancedScatterChart.RMask) === EnhancedScatterChart.RMaskResult ? outerRadius : innerRadius;
                    const currX: number = Math.cos(i * angle) * r, currY: number = Math.sin(i * angle) * r;
                    // Our first time we simply append the coordinates, subsequet times we append a ", " to distinguish each coordinate pair.
                    if (i === 0) {
                        results = `M${currX},${currY}L`;
                    } else {
                        results += ` ${currX},${currY}`;
                    }
                }

                return `${results}Z`;
            },

            "hexagon": (size: number) => {
                const r: number = Math.sqrt(size / (EnhancedScatterChart.R6 * Math.sqrt(EnhancedScatterChart.R3))),
                    r2: number = Math.sqrt(size / (EnhancedScatterChart.R2 * Math.sqrt(EnhancedScatterChart.R3)));

                return `M0,${EnhancedScatterChart.R2 * r}L${-r2},${r} ${-r2},${-r} 0,${-EnhancedScatterChart.R2 * r} ${r2},${-r} ${r2},${r}Z`;
            },

            "x": (size: number) => {
                const r: number = Math.sqrt(size / EnhancedScatterChart.R10);

                return `M0,${r}L${-r},${EnhancedScatterChart.R2 * r} ${-EnhancedScatterChart.R2 * r},${r} ${-r},0 ${-EnhancedScatterChart.R2 * r},${-r} ${-r},${-EnhancedScatterChart.R2 * r} 0,${-r} ${r},${-EnhancedScatterChart.R2 * r} ${EnhancedScatterChart.R2 * r},${-r} ${r},0 ${EnhancedScatterChart.R2 * r},${r} ${r},${EnhancedScatterChart.R2 * r}Z`;
            },

            "uparrow": (size: number) => {
                const r: number = Math.sqrt(size / EnhancedScatterChart.R12);

                return `M${r},${EnhancedScatterChart.R3 * r}L${-r},${EnhancedScatterChart.R3 * r} ${-r},${-r} ${-EnhancedScatterChart.R2 * r},${-r} 0,${-EnhancedScatterChart.R3 * r} ${EnhancedScatterChart.R2 * r},${-r} ${r},${-r}Z`;
            },

            "downarrow": (size: number) => {
                const r: number = Math.sqrt(size / EnhancedScatterChart.R12);

                return `M0,${EnhancedScatterChart.R3 * r}L${(-EnhancedScatterChart.R2 * r)},${r} ${-r},${r} ${-r},${-EnhancedScatterChart.R3 * r} ${r},${-EnhancedScatterChart.R3 * r} ${r},${r} ${EnhancedScatterChart.R2 * r},${r}Z`;
            }
        });

        const defaultValue: ShapeFunction = customSymbolTypes.entries()[0].value;
        if (!shape) {
            return defaultValue;
        } else if (isNaN(shape)) {
            return customSymbolTypes[shape && shape.toString().toLowerCase()] || defaultValue;
        }
        const result: ShapeEntry = customSymbolTypes.entries()[Math.floor(shape)];

        return result ? result.value : defaultValue;
    }