private recommend()

in src/common/components/recommend-color.tsx [83:181]
94 lines of code
8 McCabe index (conditional complexity)

    private recommend(fore: number[], back: number[], colorContrast: number) {
        const foreOriginal: string = this.rgbToHex(fore[0], fore[1], fore[2]);
        const backOriginal: string = this.rgbToHex(back[0], back[1], back[2]);
        const foreLum: number = this.getLuminance(fore);
        const backLum: number = this.getLuminance(back);
        const lighter: number = Math.max(foreLum, backLum);
        const darker: number = lighter === foreLum ? backLum : foreLum;
        const contrast: number = (lighter + 0.05) / (darker + 0.05);

        let lightened: number[], darkened: number[];

        if (lighter === foreLum) {
            lightened = fore;
            darkened = back;
        } else {
            lightened = back;
            darkened = fore;
        }

        const recommendLightened: object = this.recommendAColor(
            contrast,
            lightened,
            darker,
            true,
            colorContrast,
        );
        const recommendDarkened: object = this.recommendAColor(
            contrast,
            darkened,
            lighter,
            false,
            colorContrast,
        );

        let sentence: string = ' ',
            foreRec: string,
            backRec: string;

        if (lighter === foreLum) {
            if (recommendLightened[1] > colorContrast) {
                foreRec = this.rgbToHex(
                    recommendLightened[0][0],
                    recommendLightened[0][1],
                    recommendLightened[0][2],
                );
                sentence = this.createSentence(
                    foreRec,
                    recommendLightened[1].toFixed(2),
                    sentence,
                    true,
                    backOriginal,
                );
            }
            if (recommendDarkened[1] > colorContrast) {
                backRec = this.rgbToHex(
                    recommendDarkened[0][0],
                    recommendDarkened[0][1],
                    recommendDarkened[0][2],
                );
                sentence += this.createSentence(
                    backRec,
                    recommendDarkened[1].toFixed(2),
                    sentence,
                    false,
                    foreOriginal,
                );
            }
        } else {
            if (recommendDarkened[1] > colorContrast) {
                foreRec = this.rgbToHex(
                    recommendDarkened[0][0],
                    recommendDarkened[0][1],
                    recommendDarkened[0][2],
                );
                sentence = this.createSentence(
                    foreRec,
                    recommendDarkened[1].toFixed(2),
                    sentence,
                    true,
                    backOriginal,
                );
            }
            if (recommendLightened[1] > colorContrast) {
                backRec = this.rgbToHex(
                    recommendLightened[0][0],
                    recommendLightened[0][1],
                    recommendLightened[0][2],
                );
                sentence += this.createSentence(
                    backRec,
                    recommendLightened[1].toFixed(2),
                    sentence,
                    false,
                    foreOriginal,
                );
            }
        }
        return sentence;
    }