• Version 0.15.0
  • Published
  • 502 kB
  • 1 dependency
  • ISC license


npm i ng2-bs3-modal
yarn add ng2-bs3-modal
pnpm add ng2-bs3-modal


Angular Boostrap 3 Modal Component



class BsModalBodyComponent

class BsModalBodyComponent {}

    class BsModalComponent

    class BsModalComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy {}


      constructor(element: ElementRef, service: BsModalService, zone: NgZone);

        property animation

        animation: boolean;

          property backdrop

          backdrop: string | boolean;

            property cssClass

            cssClass: string;

              property fadeClass

              readonly fadeClass: boolean;

                property hiding

                hiding: boolean;

                  property keyboard

                  keyboard: boolean;

                    property modalClass

                    readonly modalClass: boolean;

                      property onClose

                      onClose: EventEmitter<any>;

                        property onDismiss

                        onDismiss: EventEmitter<BsModalHideType>;

                          property onHide

                          onHide: EventEmitter<any>;

                            property onLoaded

                            onLoaded: EventEmitter<any>;

                              property onOpen

                              onOpen: EventEmitter<any>;

                                property onShow

                                onShow: EventEmitter<Event>;

                                  property roleAttr

                                  readonly roleAttr: string;

                                    property showing

                                    showing: boolean;

                                      property size

                                      size: string;

                                        property tabindexAttr

                                        readonly tabindexAttr: string;

                                          property visible

                                          visible: boolean;

                                            method close

                                            close: (value?: any) => Promise<{}>;

                                              method dismiss

                                              dismiss: () => Promise<{}>;

                                                method focus

                                                focus: () => void;

                                                  method getCssClasses

                                                  getCssClasses: () => string;

                                                    method ngAfterViewInit

                                                    ngAfterViewInit: () => void;

                                                      method ngOnChanges

                                                      ngOnChanges: () => void;

                                                        method ngOnDestroy

                                                        ngOnDestroy: () => Promise<BsModalHideType>;

                                                          method ngOnInit

                                                          ngOnInit: () => void;

                                                            method open

                                                            open: (size?: string) => Promise<any>;

                                                              method routerCanDeactivate

                                                              routerCanDeactivate: () => any;

                                                                class BsModalFooterComponent

                                                                class BsModalFooterComponent {}


                                                                  constructor(modal: BsModalComponent);

                                                                    property closeButtonLabel

                                                                    closeButtonLabel: string;

                                                                      property dismissButtonLabel

                                                                      dismissButtonLabel: string;

                                                                        property modal

                                                                        modal: BsModalComponent;

                                                                          property showDefaultButtons

                                                                          showDefaultButtons: boolean;

                                                                            class BsModalHeaderComponent

                                                                            class BsModalHeaderComponent {}


                                                                              constructor(modal: BsModalComponent);

                                                                                property modal

                                                                                modal: BsModalComponent;

                                                                                  property showDismiss

                                                                                  showDismiss: boolean;

                                                                                    class BsModalModule

                                                                                    class BsModalModule {}

                                                                                      class BsModalService

                                                                                      class BsModalService {}



                                                                                          property onBackdropClose$

                                                                                          onBackdropClose$: Observable<BsModalHideType>;

                                                                                            property onKeyboardClose$

                                                                                            onKeyboardClose$: Observable<BsModalHideType>;

                                                                                              property onModalStack$

                                                                                              onModalStack$: Observable<Event>;

                                                                                                method add

                                                                                                add: (modal: BsModalComponent) => void;

                                                                                                  method dismissAll

                                                                                                  dismissAll: () => Promise<{}[]>;

                                                                                                    method focusNext

                                                                                                    focusNext: () => void;

                                                                                                      method remove

                                                                                                      remove: (modal: BsModalComponent) => void;

                                                                                                        class BsModalSize

                                                                                                        class BsModalSize {}

                                                                                                          property Large

                                                                                                          static Large: string;

                                                                                                            property Small

                                                                                                            static Small: string;

                                                                                                              method isValidSize

                                                                                                              static isValidSize: (size: string) => boolean;

                                                                                                                class ɵa

                                                                                                                class BsAutofocusDirective {}


                                                                                                                  constructor(el: ElementRef, modal: BsModalComponent);


                                                                                                                    interface BsModalHideEvent

                                                                                                                    interface BsModalHideEvent {}

                                                                                                                      property event

                                                                                                                      event: Event;

                                                                                                                        property type

                                                                                                                        type: BsModalHideType;

                                                                                                                          interface BsModalOptions

                                                                                                                          interface BsModalOptions {}

                                                                                                                            property backdrop

                                                                                                                            backdrop: string | boolean;

                                                                                                                              property keyboard

                                                                                                                              keyboard: boolean;


                                                                                                                                enum BsModalHideType

                                                                                                                                enum BsModalHideType {
                                                                                                                                Close = 0,
                                                                                                                                Dismiss = 1,
                                                                                                                                Backdrop = 2,
                                                                                                                                Keyboard = 3,
                                                                                                                                RouteChange = 4,
                                                                                                                                Destroy = 5,

                                                                                                                                  member Backdrop

                                                                                                                                  Backdrop = 2

                                                                                                                                    member Close

                                                                                                                                    Close = 0

                                                                                                                                      member Destroy

                                                                                                                                      Destroy = 5

                                                                                                                                        member Dismiss

                                                                                                                                        Dismiss = 1

                                                                                                                                          member Keyboard

                                                                                                                                          Keyboard = 3

                                                                                                                                            member RouteChange

                                                                                                                                            RouteChange = 4

                                                                                                                                              Package Files (12)

                                                                                                                                              Dependencies (1)

                                                                                                                                              Dev Dependencies (0)

                                                                                                                                              No dev dependencies.

                                                                                                                                              Peer Dependencies (5)


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

                                                                                                                                              You may also use to create a custom badge linking to

                                                                                                                                              • Markdown
                                                                                                                                              • HTML
                                                                                                                                                <a href=""><img src="" alt=""></a>