@mintplayer/ng-bootstrap 18.5.0 → 20.0.0-preview.1

package/navbar/index.d.ts

@@ -1 +1,153 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { ElementRef, TemplateRef, AfterContentChecked, DestroyRef, QueryList, Injector, AfterContentInit, AfterViewInit, OnDestroy } from '@angular/core';
+import { Color, Breakpoint } from '@mintplayer/ng-bootstrap';
+import { Observable, BehaviorSubject } from 'rxjs';
+import * as i10 from '@angular/common';
+import * as i11 from '@mintplayer/ng-click-outside';
+import * as i12 from '@mintplayer/ng-bootstrap/container';
+import * as i13 from '@mintplayer/ng-bootstrap/user-agent';
+import * as i14 from '@mintplayer/ng-bootstrap/no-noscript';
+import * as i15 from '@mintplayer/ng-bootstrap/has-overlay';
+import * as i16 from '@mintplayer/ng-bootstrap/dropdown-divider';
+import * as i17 from '@mintplayer/ng-bootstrap/navbar-toggler';
+
+declare class BsNavbarComponent {
+    constructor();
+    onWindowResize(): void;
+    nav: ElementRef;
+    autoclose: boolean;
+    expandButtonTemplate: TemplateRef<any> | null;
+    expandClass$: Observable<string | null>;
+    wAutoClass$: Observable<string | null>;
+    dNoneClass$: Observable<string | null>;
+    isExpanded$: BehaviorSubject<boolean>;
+    windowWidth$: BehaviorSubject<number | null>;
+    isResizing$: BehaviorSubject<boolean>;
+    expandAt$: Observable<number | null>;
+    isSmallMode$: Observable<boolean>;
+    backgroundColorClass$: Observable<string[]>;
+    navClassList$: Observable<string[]>;
+    toggleExpanded(): void;
+    color$: BehaviorSubject<Color | null>;
+    get color(): Color | null;
+    set color(value: Color | null);
+    breakPoint$: BehaviorSubject<Breakpoint | null>;
+    get breakpoint(): Breakpoint | null;
+    set breakpoint(value: Breakpoint | null);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarComponent, "bs-navbar", never, { "autoclose": { "alias": "autoclose"; "required": false; }; "color": { "alias": "color"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; }, {}, never, ["bs-navbar-brand", "*"], false, never>;
+}
+
+declare class BsNavbarNavComponent {
+    constructor(bsNavbar: BsNavbarComponent);
+    bsNavbar: BsNavbarComponent;
+    collapse$: BehaviorSubject<boolean>;
+    windowWidth$: BehaviorSubject<number | null>;
+    showNavs$: Observable<boolean>;
+    isResizing$: BehaviorSubject<boolean>;
+    set collapse(value: boolean);
+    get collapse(): boolean;
+    onWindowResize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarNavComponent, "bs-navbar-nav", never, { "collapse": { "alias": "collapse"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsNavbarItemComponent implements AfterContentChecked {
+    private navbar;
+    private destroy;
+    private platformId;
+    constructor(navbar: BsNavbarComponent, element: ElementRef, destroy: DestroyRef, platformId: Object, parentDropdown: BsNavbarDropdownComponent);
+    element: ElementRef;
+    parentDropdown: BsNavbarDropdownComponent;
+    hasDropdown: boolean;
+    anchorTag: HTMLAnchorElement | null;
+    dropdowns: QueryList<BsNavbarDropdownComponent>;
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarItemComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarItemComponent, "bs-navbar-item", never, {}, {}, ["dropdowns"], ["*"], false, never>;
+}
+
+declare class BsNavbarDropdownComponent {
+    private navbar;
+    element: ElementRef<HTMLElement>;
+    private injector;
+    private document;
+    constructor(navbar: BsNavbarComponent, parentDropdown: BsNavbarDropdownComponent, navbarItem: BsNavbarItemComponent, element: ElementRef<HTMLElement>, injector: Injector, document: Document, platformId: Object);
+    private isAttached;
+    private domPortal?;
+    private overlay?;
+    set showInOverlay(value: boolean);
+    autoclose: boolean;
+    navbarItem: BsNavbarItemComponent;
+    parentDropdown: BsNavbarDropdownComponent;
+    dropdownElement: ElementRef<HTMLDivElement>;
+    isBrowser: boolean;
+    topPos$: BehaviorSubject<number | null>;
+    maxHeight$: Observable<string | null>;
+    maxHeightOrNull$: Observable<string | null>;
+    isVisible$: BehaviorSubject<boolean>;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    get elementsToExclude(): HTMLElement[];
+    childDropdowns: QueryList<BsNavbarDropdownComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarDropdownComponent, [null, { optional: true; host: true; skipSelf: true; }, { host: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarDropdownComponent, "bs-navbar-dropdown", never, { "autoclose": { "alias": "autoclose"; "required": false; }; }, {}, ["childDropdowns"], ["*"], false, never>;
+}
+
+declare class DropdownToggleDirective implements AfterContentInit {
+    private elementRef;
+    private bsNavbarItem;
+    constructor(elementRef: ElementRef<HTMLAnchorElement>, bsNavbarItem: BsNavbarItemComponent, parentDropdown: BsNavbarDropdownComponent);
+    childDropdowns: QueryList<BsNavbarDropdownComponent>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownToggleDirective, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownToggleDirective, "bs-navbar-item", never, {}, {}, ["childDropdowns"], never, false, never>;
+}
+
+declare class NavLinkDirective {
+    private elementRef;
+    constructor(elementRef: ElementRef<HTMLAnchorElement>, parentNavbar: BsNavbarComponent, parentDropdown: BsNavbarDropdownComponent);
+    cursorPointer: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavLinkDirective, [null, { optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavLinkDirective, "bs-navbar-item > li > a", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsNavbarContentDirective implements AfterViewInit, OnDestroy {
+    private element;
+    private platformId;
+    constructor(element: ElementRef, platformId: any);
+    private viewInit$;
+    private navbar$;
+    resizeObserver: ResizeObserver | null;
+    initialPadding: number;
+    set navbar(value: BsNavbarComponent | undefined);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsNavbarContentDirective, "[bsNavbarContent]", never, { "navbar": { "alias": "bsNavbarContent"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsNavbarBrandComponent {
+    routerLink: any[];
+    mxAuto: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarBrandComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarBrandComponent, "bs-navbar-brand", never, { "routerLink": { "alias": "routerLink"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsExpandButtonDirective {
+    constructor(navbar: BsNavbarComponent, templateRef: TemplateRef<any>);
+    static ngTemplateContextGuard(dir: BsExpandButtonDirective, ctx: any): ctx is BsExpandButtonContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsExpandButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsExpandButtonDirective, "[bsExpandButton]", never, {}, {}, never, never, false, never>;
+}
+declare class BsExpandButtonContext {
+    $implicit: boolean;
+}
+
+declare class BsNavbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsNavbarModule, [typeof BsNavbarComponent, typeof BsNavbarNavComponent, typeof BsNavbarDropdownComponent, typeof BsNavbarItemComponent, typeof DropdownToggleDirective, typeof NavLinkDirective, typeof BsNavbarContentDirective, typeof BsNavbarBrandComponent, typeof BsExpandButtonDirective], [typeof i10.AsyncPipe, typeof i10.NgTemplateOutlet, typeof i11.ClickOutsideDirective, typeof i12.BsContainerComponent, typeof i13.BsUserAgentDirective, typeof i14.BsNoNoscriptDirective, typeof i15.BsHasOverlayComponent, typeof i16.BsDropdownDividerDirective, typeof i17.BsNavbarTogglerComponent], [typeof BsNavbarComponent, typeof BsNavbarNavComponent, typeof BsNavbarDropdownComponent, typeof BsNavbarItemComponent, typeof DropdownToggleDirective, typeof NavLinkDirective, typeof BsNavbarContentDirective, typeof BsNavbarBrandComponent, typeof BsExpandButtonDirective, typeof i16.BsDropdownDividerDirective, typeof i17.BsNavbarTogglerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsNavbarModule>;
+}
+
+export { BsExpandButtonContext, BsExpandButtonDirective, BsNavbarBrandComponent, BsNavbarComponent, BsNavbarContentDirective, BsNavbarDropdownComponent, BsNavbarItemComponent, BsNavbarModule, BsNavbarNavComponent, DropdownToggleDirective, NavLinkDirective };

package/navbar-toggler/index.d.ts

@@ -1 +1,17 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+declare class BsNavbarTogglerComponent {
+    constructor();
+    state$: BehaviorSubject<boolean>;
+    stateChange: EventEmitter<boolean>;
+    get state(): boolean;
+    set state(value: boolean);
+    toggleOnClick: boolean;
+    toggleState(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavbarTogglerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsNavbarTogglerComponent, "bs-navbar-toggler", never, { "state": { "alias": "state"; "required": false; }; "toggleOnClick": { "alias": "toggleOnClick"; "required": false; }; }, { "stateChange": "stateChange"; }, never, never, true, never>;
+}
+
+export { BsNavbarTogglerComponent };

package/navigation-lock/index.d.ts

@@ -1 +1,64 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import * as i3 from '@angular/router';
+import { Router, ActivatedRoute, ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { Observable } from 'rxjs';
+import * as i2 from '@angular/common';
+
+/**
+ * Places a navigation lock on this page.
+ *
+ * Don't forget to add the following to your route:
+ *
+ * ```ts
+ * canDeactivate: [BsNavigationLockGuard]
+ * ```
+ *
+ * and implement the `BsHasNavigationLock` on the page:
+ *
+ * ```ts
+ * ViewChild('navigationLock') navigationLock!: BsNavigationLockDirective;
+ * ```
+ *
+ **/
+declare class BsNavigationLockDirective {
+    private router;
+    private route;
+    constructor(router: Router, route: ActivatedRoute);
+    canExit?: boolean | (() => boolean) | Observable<boolean>;
+    exitMessage?: string;
+    requestCanExit(): Promise<boolean>;
+    onBeforeUnload(ev: BeforeUnloadEvent): Promise<string | undefined>;
+    onUnload(ev: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavigationLockDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsNavigationLockDirective, "[bsNavigationLock]", ["bsNavigationLock"], { "canExit": { "alias": "canExit"; "required": false; }; "exitMessage": { "alias": "exitMessage"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsNavigationLockModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavigationLockModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsNavigationLockModule, [typeof BsNavigationLockDirective], [typeof i2.CommonModule, typeof i3.RouterModule], [typeof BsNavigationLockDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsNavigationLockModule>;
+}
+
+/**
+ * Implement this interface on pages that use the `<... bsNavigationLock>` directive:
+ *
+ * @example
+ *
+ * ```ts
+ * ViewChild('navigationLock') navigationLock!: BsNavigationLockDirective;
+ * ```
+ *
+ * Don't forget to add the `canDeactivate: [BsNavigationLockGuard]` guard to your page route.
+ */
+interface BsHasNavigationLock {
+    navigationLock: BsNavigationLockDirective;
+}
+
+declare class BsNavigationLockGuard {
+    canDeactivate(component: BsHasNavigationLock, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean | UrlTree>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNavigationLockGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BsNavigationLockGuard>;
+}
+
+export { BsNavigationLockDirective, BsNavigationLockGuard, BsNavigationLockModule };
+export type { BsHasNavigationLock };

package/no-noscript/index.d.ts

@@ -1 +1,11 @@
-export * from './src';
+import * as i0 from '@angular/core';
+
+declare class BsNoNoscriptDirective {
+    private platformId;
+    constructor(platformId: Object);
+    isNoScript: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsNoNoscriptDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsNoNoscriptDirective, "[bsNoNoscript]", never, {}, {}, never, never, true, never>;
+}
+
+export { BsNoNoscriptDirective };

package/offcanvas/index.d.ts

@@ -1 +1,112 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { TemplateRef, EventEmitter, AfterViewInit, OnDestroy, Injector, DestroyRef, ComponentRef, ElementRef } from '@angular/core';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { Position } from '@mintplayer/ng-bootstrap';
+import * as i9 from '@angular/cdk/overlay';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { AnimationBuilder } from '@angular/animations';
+import * as i8 from '@angular/common';
+import * as i10 from '@mintplayer/ng-bootstrap/has-overlay';
+
+declare class BsOffcanvasComponent {
+    constructor(contentTemplate: TemplateRef<any>);
+    contentTemplate: TemplateRef<any>;
+    visibility$: Observable<string>;
+    disableTransition$: BehaviorSubject<boolean>;
+    offcanvasClass$: BehaviorSubject<string | null>;
+    overflowClass$: Observable<string | null>;
+    width$: Observable<number | null>;
+    height$: Observable<number | null>;
+    hasBackdrop$: BehaviorSubject<boolean>;
+    show$: Observable<boolean>;
+    showBackdrop$: Observable<boolean>;
+    position$: BehaviorSubject<Position>;
+    set position(value: Position);
+    get position(): Position;
+    size$: BehaviorSubject<number | null>;
+    set size(value: number | null);
+    get size(): number | null;
+    isVisible$: BehaviorSubject<boolean>;
+    isVisibleChange: EventEmitter<boolean>;
+    set isVisible(value: boolean);
+    get isVisible(): boolean;
+    backdropClick: EventEmitter<MouseEvent>;
+    onBackdropClick(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsOffcanvasComponent, "bs-offcanvas-holder", never, { "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; }, { "isVisibleChange": "isVisibleChange"; "backdropClick": "backdropClick"; }, never, never, false, never>;
+}
+
+declare class BsOffcanvasHostComponent implements AfterViewInit, OnDestroy {
+    private overlayService;
+    private rootInjector;
+    private destroy;
+    private portalFactory;
+    constructor(overlayService: Overlay, rootInjector: Injector, destroy: DestroyRef, portalFactory: (injector: Injector) => ComponentPortal<any>);
+    content: TemplateRef<any>;
+    overlayRef: OverlayRef;
+    component: ComponentRef<BsOffcanvasComponent>;
+    viewInited$: BehaviorSubject<boolean>;
+    isVisible$: BehaviorSubject<boolean>;
+    size$: BehaviorSubject<number | null>;
+    position$: BehaviorSubject<Position>;
+    hasBackdrop$: BehaviorSubject<boolean>;
+    backdropClick: EventEmitter<MouseEvent>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    isVisibleChange: EventEmitter<boolean>;
+    set isVisible(value: boolean);
+    get isVisible(): boolean;
+    set position(value: Position);
+    get position(): Position;
+    set size(value: number | null);
+    get size(): number | null;
+    set hasBackdrop(value: boolean);
+    get hasBackdrop(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BsOffcanvasHostComponent, "bs-offcanvas", never, { "isVisible": { "alias": "isVisible"; "required": false; }; "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; }, { "backdropClick": "backdropClick"; "isVisibleChange": "isVisibleChange"; }, never, never, false, never>;
+}
+
+declare class BsOffcanvasContentDirective {
+    constructor(offcanvasHost: BsOffcanvasHostComponent, template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsOffcanvasContentDirective, "[bsOffcanvasContent]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BsOffcanvasCloseDirective {
+    private offcanvas;
+    constructor(offcanvas: BsOffcanvasHostComponent);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsOffcanvasCloseDirective, "[bsOffcanvasClose]", never, {}, {}, never, never, false, never>;
+}
+
+declare class OffcanvasHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OffcanvasHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OffcanvasHeaderComponent, "bs-offcanvas-header", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class OffcanvasBodyComponent {
+    noPadding: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OffcanvasBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OffcanvasBodyComponent, "bs-offcanvas-body", never, { "noPadding": { "alias": "noPadding"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BsOffcanvasPushDirective {
+    private element;
+    private builder;
+    constructor(element: ElementRef<HTMLElement>, builder: AnimationBuilder);
+    private offcanvas$;
+    private initialOverflowX?;
+    set offcanvas(value: BsOffcanvasHostComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasPushDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BsOffcanvasPushDirective, "[bsOffcanvasPush]", never, { "offcanvas": { "alias": "bsOffcanvasPush"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BsOffcanvasModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOffcanvasModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BsOffcanvasModule, [typeof BsOffcanvasComponent, typeof BsOffcanvasContentDirective, typeof BsOffcanvasHostComponent, typeof BsOffcanvasCloseDirective, typeof OffcanvasHeaderComponent, typeof OffcanvasBodyComponent, typeof BsOffcanvasPushDirective], [typeof i8.AsyncPipe, typeof i8.NgTemplateOutlet, typeof i9.OverlayModule, typeof i10.BsHasOverlayComponent], [typeof BsOffcanvasComponent, typeof BsOffcanvasContentDirective, typeof BsOffcanvasHostComponent, typeof BsOffcanvasCloseDirective, typeof OffcanvasHeaderComponent, typeof OffcanvasBodyComponent, typeof BsOffcanvasPushDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BsOffcanvasModule>;
+}
+
+export { BsOffcanvasCloseDirective, BsOffcanvasComponent, BsOffcanvasContentDirective, BsOffcanvasHostComponent, BsOffcanvasModule, BsOffcanvasPushDirective, OffcanvasBodyComponent, OffcanvasHeaderComponent };

package/ordinal-number/index.d.ts

@@ -1 +1,13 @@
-export * from './src';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+
+declare class BsOrdinalNumberPipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(value: string | SafeHtml | null, ...args: string[]): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BsOrdinalNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BsOrdinalNumberPipe, "ordinalNumber", true>;
+}
+
+export { BsOrdinalNumberPipe };