text: 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;
      var classNames = getGlobalClassNames(globalClassNames, theme);
      var fieldPrefixSuffix = {
          background: semanticColors.disabledBackground,
          color: !disabled ? semanticColors.inputPlaceholderText : semanticColors.disabledText,
          display: 'flex',
          alignItems: 'center',
          padding: '0 10px',
          lineHeight: 1,
          whiteSpace: 'nowrap',
          flexShrink: 0
      };
      return {
          root: [
              classNames.root,
              theme.fonts.medium,
              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.inputBackground,
                  cursor: 'text',
                  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,
                  cursor: 'default'
              },
              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: [
              theme.fonts.medium,
              classNames.field,
              normalize,
              {
                  fontSize: FontSizes.medium,
                  borderRadius: 0,
                  border: 'none',
                  background: 'none',
                  backgroundColor: 'transparent',
                  color: semanticColors.inputText,
                  padding: '0 12px',
                  width: '100%',
                  minWidth: 0,
                  textOverflow: 'ellipsis',
                  outline: 0,
                  selectors: {
                      '&:active, &:focus, &:hover': { outline: 0 },
                      '::-ms-clear': {
                          display: 'none'
                      },
                      '::placeholder': [
                          theme.fonts.medium,
                          {
                              color: semanticColors.inputPlaceholderText,
                              opacity: 1
                          }
                      ],
                      ':-ms-input-placeholder': [
                          theme.fonts.medium,
                          {
                              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',
                  color: semanticColors.disabledText,
                  selectors: {
                      '::placeholder': {
                          color: semanticColors.disabledText
                      },
                      ':-ms-input-placeholder': {
                          color: semanticColors.disabledText
                      }
                  }
              },
              underlined && {
                  textAlign: 'left'
              },
              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
              },
              disabled && {
                  color: semanticColors.disabledText
              },
              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