import { AnimationClassNames, FontSizes, getGlobalClassNames, HighContrastSelector, normalize } from '../../Styling';
var globalClassNames = {
    root: 'ms-TextField',
    description: 'ms-TextField-description',
    errorMessage: 'ms-TextField-errorMessage',
    field: 'ms-TextField-field',
    fieldGroup: 'ms-TextField-fieldGroup',
    prefix: 'ms-TextField-prefix',
    suffix: 'ms-TextField-suffix',
    wrapper: 'ms-TextField-wrapper',
    multiline: 'ms-TextField--multiline',
    borderless: 'ms-TextField--borderless',
    underlined: 'ms-TextField--underlined',
    unresizable: 'ms-TextField--unresizable',
    required: 'is-required',
    disabled: 'is-disabled',
    active: 'is-active'
};
function getLabelStyles(props) {
    var underlined = props.underlined, disabled = props.disabled, focused = props.focused;
    return function () {
        return ({
            root: [
                underlined &&
                    disabled && {
                    color: props.theme.palette.neutralTertiary
                },
                underlined && {
                    fontSize: FontSizes.medium,
                    marginRight: 8,
                    paddingLeft: 12,
                    paddingRight: 0,
                    lineHeight: '22px',
                    height: 32
                },
                underlined &&
                    focused && {
                    selectors: (_a = {},
                        _a[HighContrastSelector] = {
                            height: 31 // -1px to prevent jumpiness in HC with the increased border-width to 2px
                        },
                        _a)
                }
            ]
        });
        var _a;
    };
}
export function getStyles(props) {
    var theme = props.theme, className = props.className, disabled = props.disabled, focused = props.focused, required = props.required, multiline = props.multiline, hasLabel = props.hasLabel, borderless = props.borderless, underlined = props.underlined, hasIcon = props.hasIcon, resizable = props.resizable, hasErrorMessage = props.hasErrorMessage, iconClass = props.iconClass, inputClassName = props.inputClassName, autoAdjustHeight = props.autoAdjustHeight;
    var semanticColors = theme.semanticColors, palette = theme.palette;
    var classNames = getGlobalClassNames(globalClassNames, theme);
    var fieldPrefixSuffix = {
        background: palette.neutralLighter,
        color: palette.neutralSecondary,
        display: 'flex',
        alignItems: 'center',
        padding: '0 10px',
        lineHeight: 1,
        whiteSpace: 'nowrap'
    };
    return {
        root: [
            classNames.root,
            required && classNames.required,
            disabled && classNames.disabled,
            focused && classNames.active,
            multiline && classNames.multiline,
            borderless && classNames.borderless,
            underlined && classNames.underlined,
            normalize,
            {
                position: 'relative'
            },
            className
        ],
        wrapper: [
            classNames.wrapper,
            underlined && {
                display: 'flex',
                borderBottomWidth: 1,
                borderBottomStyle: 'solid',
                borderBottomColor: semanticColors.inputBorder,
                width: '100%'
            },
            hasErrorMessage &&
                underlined &&
                !disabled && {
                borderBottomColor: semanticColors.errorText,
                selectors: {
                    ':hover': {
                        borderBottomColor: semanticColors.errorText,
                        selectors: (_a = {},
                            _a[HighContrastSelector] = {
                                borderBottomColor: 'Highlight'
                            },
                            _a)
                    }
                }
            },
            underlined &&
                disabled && {
                borderBottomColor: semanticColors.disabledBackground
            },
            underlined &&
                !disabled &&
                !focused &&
                !hasErrorMessage && {
                selectors: {
                    ':hover': {
                        borderBottomColor: semanticColors.inputBorderHovered,
                        selectors: (_b = {},
                            _b[HighContrastSelector] = {
                                borderBottomColor: 'Highlight'
                            },
                            _b)
                    }
                }
            },
            underlined &&
                focused && {
                borderBottomColor: !hasErrorMessage ? semanticColors.inputFocusBorderAlt : semanticColors.errorText,
                selectors: (_c = {},
                    _c[HighContrastSelector] = {
                        borderBottomWidth: 2,
                        borderBottomColor: 'Highlight'
                    },
                    _c)
            }
        ],
        fieldGroup: [
            classNames.fieldGroup,
            normalize,
            {
                border: "1px solid " + semanticColors.inputBorder,
                background: semanticColors.bodyBackground,
                height: 32,
                display: 'flex',
                flexDirection: 'row',
                alignItems: 'stretch',
                position: 'relative',
                selectors: {
                    ':hover': {
                        selectors: (_d = {},
                            _d[HighContrastSelector] = {
                                borderColor: 'Highlight'
                            },
                            _d)
                    }
                }
            },
            multiline && {
                minHeight: '60px',
                height: 'auto',
                display: 'flex'
            },
            borderless && {
                border: 'none'
            },
            !focused &&
                !disabled && {
                selectors: {
                    ':hover': {
                        borderColor: semanticColors.inputBorderHovered
                    }
                }
            },
            focused && {
                borderColor: semanticColors.inputFocusBorderAlt,
                selectors: (_e = {},
                    _e[HighContrastSelector] = {
                        borderWidth: 2,
                        borderColor: 'Highlight'
                    },
                    _e)
            },
            disabled && {
                backgroundColor: semanticColors.disabledBackground,
                borderColor: semanticColors.disabledBackground
            },
            underlined && {
                flex: '1 1 0px',
                border: 'none',
                textAlign: 'left'
            },
            underlined &&
                focused && {
                selectors: (_f = {},
                    _f[HighContrastSelector] = {
                        height: 31 // -1px to prevent jumpiness in HC with the increased border-width to 2px
                    },
                    _f)
            },
            underlined &&
                disabled && {
                backgroundColor: 'transparent'
            },
            hasErrorMessage && {
                borderColor: semanticColors.errorText,
                selectors: {
                    '&:focus, &:hover': {
                        borderColor: semanticColors.errorText
                    }
                }
            },
            hasErrorMessage &&
                focused && {
                borderColor: semanticColors.errorText
            },
            !hasLabel &&
                required && {
                selectors: (_g = {
                        ':after': {
                            content: "'*'",
                            color: semanticColors.errorText,
                            position: 'absolute',
                            top: -5,
                            right: -10
                        }
                    },
                    _g[HighContrastSelector] = {
                        selectors: {
                            ':after': {
                                right: -14 // moving the * 4 pixel to right to alleviate border clipping in HC mode.
                            }
                        }
                    },
                    _g)
            }
        ],
        field: [
            classNames.field,
            normalize,
            {
                fontSize: FontSizes.medium,
                borderRadius: 0,
                border: 'none',
                background: 'none',
                backgroundColor: 'transparent',
                color: semanticColors.bodyText,
                padding: '0 12px',
                width: '100%',
                minWidth: 0,
                textOverflow: 'ellipsis',
                outline: 0,
                selectors: {
                    '&:active, &:focus, &:hover': { outline: 0 },
                    '::-ms-clear': {
                        display: 'none'
                    },
                    '::placeholder': {
                        color: semanticColors.inputPlaceholderText,
                        opacity: 1
                    },
                    ':-ms-input-placeholder': {
                        color: semanticColors.inputPlaceholderText,
                        opacity: 1
                    }
                }
            },
            multiline &&
                !resizable && [
                classNames.unresizable,
                {
                    resize: 'none'
                }
            ],
            multiline && {
                minHeight: 'inherit',
                lineHeight: 17,
                flexGrow: 1,
                paddingTop: 6,
                overflow: 'auto',
                width: '100%'
            },
            multiline &&
                autoAdjustHeight && {
                overflow: 'hidden'
            },
            hasIcon && {
                paddingRight: 24
            },
            multiline &&
                hasIcon && {
                paddingRight: 40
            },
            disabled && {
                backgroundColor: 'transparent',
                borderColor: 'transparent'
            },
            underlined && {
                textAlign: 'left'
            },
            underlined &&
                disabled && {
                backgroundColor: 'transparent',
                color: semanticColors.disabledText
            },
            focused &&
                !borderless && {
                selectors: (_h = {},
                    _h[HighContrastSelector] = {
                        paddingLeft: 11,
                        paddingRight: 11
                    },
                    _h)
            },
            focused &&
                multiline &&
                !borderless && {
                selectors: (_j = {},
                    _j[HighContrastSelector] = {
                        paddingTop: 4 // take into consideration the 2px increased border-width (not when borderless).
                    },
                    _j)
            },
            inputClassName
        ],
        icon: [
            multiline && {
                paddingRight: 24,
                paddingBottom: 8,
                alignItems: 'flex-end'
            },
            {
                pointerEvents: 'none',
                position: 'absolute',
                bottom: 5,
                right: 8,
                top: 'auto',
                fontSize: 16,
                lineHeight: 18
            },
            iconClass
        ],
        description: [
            classNames.description,
            {
                color: semanticColors.bodySubtext,
                fontSize: FontSizes.xSmall
            }
        ],
        errorMessage: [
            classNames.errorMessage,
            AnimationClassNames.slideDownIn20,
            theme.fonts.small,
            {
                color: semanticColors.errorText,
                margin: 0,
                paddingTop: 5,
                display: 'flex',
                alignItems: 'center'
            }
        ],
        prefix: [classNames.prefix, fieldPrefixSuffix],
        suffix: [classNames.suffix, fieldPrefixSuffix],
        subComponentStyles: {
            label: getLabelStyles(props)
        }
    };
    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
}
//# sourceMappingURL=TextField.styles.js.map