• Version 2.0.0-alpha.8-3
  • Published
  • No dependencies
  • MIT license


npm i @angular2-material/input
yarn add @angular2-material/input
pnpm add @angular2-material/input


Angular 2 Material input






    class MdHint

    class MdHint {}
    • The hint directive, used to tag content as hint labels (going under the input).

    property align

    align: 'start' | 'end';

      class MdInput

      class MdInput implements ControlValueAccessor, AfterContentInit, OnChanges {}
      • Component that represents a text input. It encapsulates the HTMLElement and improve on its behaviour, along with styling it according to the Material Design.

      property align

      align: 'start' | 'end';
      • Bindings.

      property ariaDisabled

      ariaDisabled: boolean;

        property ariaInvalid

        ariaInvalid: boolean;

          property ariaLabel

          ariaLabel: string;
          • Aria related inputs.

          property ariaLabelledBy

          ariaLabelledBy: string;

            property ariaRequired

            ariaRequired: boolean;

              property autocapitalize

              autocapitalize: string;

                property autocomplete

                autocomplete: string;

                  property autocorrect

                  autocorrect: string;

                    property autofocus

                    autofocus: boolean;

                      property characterCount

                      readonly characterCount: number;

                        property disabled

                        disabled: boolean;

                          property dividerColor

                          dividerColor: 'primary' | 'accent' | 'warn';

                            property empty

                            readonly empty: boolean;

                              property floatingPlaceholder

                              floatingPlaceholder: boolean;

                                property focused

                                readonly focused: boolean;
                                • Readonly properties.

                                property hintLabel

                                hintLabel: string;

                                  property id

                                  id: string;

                                    property inputId

                                    readonly inputId: string;

                                      property list

                                      list: string;

                                        property max

                                        max: string | number;

                                          property maxlength

                                          maxlength: number;

                                            property min

                                            min: string | number;

                                              property minlength

                                              minlength: number;

                                                property name

                                                name: string;

                                                  property onBlur

                                                  readonly onBlur: Observable<FocusEvent>;

                                                    property onFocus

                                                    readonly onFocus: Observable<FocusEvent>;

                                                      property placeholder

                                                      placeholder: string;

                                                        property readonly

                                                        readonly: boolean;

                                                          property required

                                                          required: boolean;

                                                            property spellcheck

                                                            spellcheck: boolean;

                                                              property step

                                                              step: number;

                                                                property tabindex

                                                                tabindex: number;

                                                                  property type

                                                                  type: string;

                                                                    property value

                                                                    value: any;

                                                                      method focus

                                                                      focus: () => void;
                                                                      • Set focus on input

                                                                      method ngAfterContentInit

                                                                      ngAfterContentInit: () => void;
                                                                      • TODO: internal

                                                                      method ngOnChanges

                                                                      ngOnChanges: (changes: { [key: string]: SimpleChange }) => void;
                                                                      • TODO: internal

                                                                      method registerOnChange

                                                                      registerOnChange: (fn: any) => void;
                                                                      • Implemented as part of ControlValueAccessor. TODO: internal

                                                                      method registerOnTouched

                                                                      registerOnTouched: (fn: any) => void;
                                                                      • Implemented as part of ControlValueAccessor. TODO: internal

                                                                      method writeValue

                                                                      writeValue: (value: any) => void;
                                                                      • Implemented as part of ControlValueAccessor. TODO: internal

                                                                      class MdInputDuplicatedHintError

                                                                      class MdInputDuplicatedHintError extends MdError {}


                                                                        constructor(align: string);

                                                                          class MdInputModule

                                                                          class MdInputModule {}

                                                                            method forRoot

                                                                            static forRoot: () => ModuleWithProviders;

                                                                              class MdInputPlaceholderConflictError

                                                                              class MdInputPlaceholderConflictError extends MdError {}



                                                                                  class MdInputUnsupportedTypeError

                                                                                  class MdInputUnsupportedTypeError extends MdError {}


                                                                                    constructor(type: string);

                                                                                      class MdPlaceholder

                                                                                      class MdPlaceholder {}
                                                                                      • The placeholder directive. The content can declare this to implement more complex placeholders.

                                                                                      Package Files (2)

                                                                                      Dependencies (0)

                                                                                      No dependencies.

                                                                                      Dev Dependencies (0)

                                                                                      No dev dependencies.

                                                                                      Peer Dependencies (2)


                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@angular2-material/input.

                                                                                      • Markdown
                                                                                      • HTML
                                                                                        <a href="https://www.jsdocs.io/package/@angular2-material/input"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>