@bravura/ui 3.8.1 → 5.0.0

package/esm2022/behavior/await.directive.mjs

@@ -0,0 +1,133 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, Inject, Input, Optional } from '@angular/core';
+import { MatProgressSpinner } from '@angular/material/progress-spinner';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/button";
+/**
+ * Use this directive on a `MatButton` element to provide an alternative view when an async operation is in progress.
+ *
+ * For example:
+ *
+ * ```
+ * <button (click)="submit();" [buiAwait]="submitSubscription" buiAwaitAriaLabel="submitting">Submit</button>
+ * ```
+ *
+ * Please refer to [Material Design](https://material.io/components/progress-indicators#circular-progress-indicators)
+ * for more details of integrating circular spinner component with action buttons.
+ *
+ * The operation is considered 'in progress' when the bound property `buiAwait` evaluates to
+ *
+ * - `true`; or
+ * - a `number` within 0 - 100; or
+ * - an instance of `rxjs/Subscription` and `buiAwait.closed` is falsy
+ *
+ * When in progress
+ *
+ * - the button's caption will be hidden;
+ * - a `<mat-progress-spinner>` will be displayed in place of the caption;
+ * - the button will be disabled by setting the property `disabled` of the `MatButton` instance.
+ */
+export class AwaitDirective {
+    constructor(_eRef, _button, _iconButton, _iconAnchor, _fab, _fabAnchor, _miniFab, _miniFabAnchor, doc, _viewCont) {
+        this._eRef = _eRef;
+        this._button = _button;
+        this._iconButton = _iconButton;
+        this._iconAnchor = _iconAnchor;
+        this._fab = _fab;
+        this._fabAnchor = _fabAnchor;
+        this._miniFab = _miniFab;
+        this._miniFabAnchor = _miniFabAnchor;
+        this.doc = doc;
+        this._viewCont = _viewCont;
+        /** The ARIA label to be put on the spinner. The default value is `"In progress"`. */
+        this.buiAwaitAriaLabel = 'In progress';
+        /** The diameter of the in-progress spinner. The default value is `20`. */
+        this.buiAwaitDiameter = 20;
+        this._processing = false;
+        this.button = _button || _iconButton || _iconAnchor || _fab || _fabAnchor || _miniFab || _miniFabAnchor;
+        if (!this.button) {
+            console.error('[buiAwait] can only be used on a Material button.');
+            return;
+        }
+    }
+    /** @ignore */
+    ngAfterViewInit() {
+        if (this.button) {
+            this._overlayEl = this.doc.createElement('div');
+            this._eRef.nativeElement.appendChild(this._overlayEl);
+            this._overlayEl.classList.add('bui-await-overlay');
+            this._overlayEl.style.cssText =
+                'display:flex; position:absolute; top:0; right:0; bottom:0; left:0; align-items: center; justify-content: center';
+            this._captionWrapper = this._eRef.nativeElement.querySelector('.mdc-button__label,.mat-icon');
+        }
+    }
+    /** @ignore */
+    ngDoCheck() {
+        const inProgress = this.buiAwait === true || (typeof this.buiAwait === 'object' && !this.buiAwait.closed) || this._isDeterminate;
+        if (inProgress !== this._processing) {
+            this._processing = inProgress;
+            this._statusChanged(this._isDeterminate ? 'determinate' : 'indeterminate');
+        }
+        if (this._isDeterminate && this._spinnerRef) {
+            this._spinnerRef.setInput('value', this.buiAwait);
+        }
+    }
+    /** @ignore */
+    get _isDeterminate() {
+        return typeof this.buiAwait === 'number' && this.buiAwait >= 0 && this.buiAwait < 100;
+    }
+    _statusChanged(mode) {
+        if (this.button) {
+            this.button.disabled = this._processing;
+            if (this._processing) {
+                this._spinnerRef = this._viewCont.createComponent(MatProgressSpinner);
+                const c = this._spinnerRef.instance;
+                c.diameter = this.buiAwaitDiameter;
+                c.mode = mode;
+                c.color = this.button.color;
+                const e = this._spinnerRef.location.nativeElement;
+                e.setAttribute('aria-label', this.buiAwaitAriaLabel);
+                this._overlayEl.appendChild(e);
+                this._captionWrapper.style.visibility = 'hidden';
+            }
+            else {
+                this._captionWrapper.style.visibility = '';
+                this._spinnerRef.destroy();
+                this._spinnerRef = undefined;
+                this._overlayEl.innerHTML = '';
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: AwaitDirective, deps: [{ token: i0.ElementRef }, { token: i1.MatButton, optional: true }, { token: i1.MatIconButton, optional: true }, { token: i1.MatIconAnchor, optional: true }, { token: i1.MatFabButton, optional: true }, { token: i1.MatFabAnchor, optional: true }, { token: i1.MatMiniFabButton, optional: true }, { token: i1.MatMiniFabAnchor, optional: true }, { token: DOCUMENT }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: AwaitDirective, selector: "[buiAwait]", inputs: { buiAwait: "buiAwait", buiAwaitAriaLabel: "buiAwaitAriaLabel", buiAwaitDiameter: "buiAwaitDiameter" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: AwaitDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[buiAwait]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.MatButton, decorators: [{
+                    type: Optional
+                }] }, { type: i1.MatIconButton, decorators: [{
+                    type: Optional
+                }] }, { type: i1.MatIconAnchor, decorators: [{
+                    type: Optional
+                }] }, { type: i1.MatFabButton, decorators: [{
+                    type: Optional
+                }] }, { type: i1.MatFabAnchor, decorators: [{
+                    type: Optional
+                }] }, { type: i1.MatMiniFabButton, decorators: [{
+                    type: Optional
+                }] }, { type: i1.MatMiniFabAnchor, decorators: [{
+                    type: Optional
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ViewContainerRef }], propDecorators: { buiAwait: [{
+                type: Input
+            }], buiAwaitAriaLabel: [{
+                type: Input
+            }], buiAwaitDiameter: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"await.directive.js","sourceRoot":"","sources":["../../../../projects/ui/behavior/await.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport {\r\n\tAfterViewInit,\r\n\tComponentRef,\r\n\tDirective,\r\n\tDoCheck,\r\n\tElementRef,\r\n\tInject,\r\n\tInput,\r\n\tOptional,\r\n\tViewContainerRef\r\n} from '@angular/core';\r\nimport {\r\n\tMatButton,\r\n\tMatFabAnchor,\r\n\tMatFabButton,\r\n\tMatIconAnchor,\r\n\tMatIconButton,\r\n\tMatMiniFabAnchor,\r\n\tMatMiniFabButton\r\n} from '@angular/material/button';\r\nimport { MatProgressSpinner, ProgressSpinnerMode } from '@angular/material/progress-spinner';\r\nimport { Subscription } from 'rxjs';\r\n\r\n/**\r\n * Use this directive on a `MatButton` element to provide an alternative view when an async operation is in progress.\r\n *\r\n * For example:\r\n *\r\n * ```\r\n * <button (click)=\"submit();\" [buiAwait]=\"submitSubscription\" buiAwaitAriaLabel=\"submitting\">Submit</button>\r\n * ```\r\n *\r\n * Please refer to [Material Design](https://material.io/components/progress-indicators#circular-progress-indicators)\r\n * for more details of integrating circular spinner component with action buttons.\r\n *\r\n * The operation is considered 'in progress' when the bound property `buiAwait` evaluates to\r\n *\r\n * - `true`; or\r\n * - a `number` within 0 - 100; or\r\n * - an instance of `rxjs/Subscription` and `buiAwait.closed` is falsy\r\n *\r\n * When in progress\r\n *\r\n * - the button's caption will be hidden;\r\n * - a `<mat-progress-spinner>` will be displayed in place of the caption;\r\n * - the button will be disabled by setting the property `disabled` of the `MatButton` instance.\r\n */\r\n@Directive({\r\n\tselector: '[buiAwait]'\r\n})\r\nexport class AwaitDirective implements AfterViewInit, DoCheck {\r\n\t/**\r\n\t * Indicates the `in progress` status of an async operation.\r\n\t *\r\n\t * The operation is considered 'in progress' when the property evaluates to\r\n\t *\r\n\t * - `true`; or\r\n\t * - a `number` within 0 - 100; or\r\n\t * - an instance of `rxjs/Subscription` and `buiAwait.closed` is falsy\r\n\t *\r\n\t * When it is a number, it represets the progress in percentage term.\r\n\t */\r\n\t@Input()\r\n\tbuiAwait: null | undefined | boolean | Subscription | number;\r\n\r\n\t/** The ARIA label to be put on the spinner. The default value is `\"In progress\"`. */\r\n\t@Input()\r\n\tbuiAwaitAriaLabel = 'In progress';\r\n\r\n\t/** The diameter of the in-progress spinner. The default value is `20`. */\r\n\t@Input()\r\n\tbuiAwaitDiameter = 20;\r\n\r\n\tprivate _overlayEl: HTMLDivElement | undefined;\r\n\tprivate _processing = false;\r\n\tprivate _spinnerRef: ComponentRef<MatProgressSpinner> | undefined;\r\n\tprivate _captionWrapper: HTMLElement | undefined;\r\n\tprivate button:\r\n\t\t| MatButton\r\n\t\t| MatIconButton\r\n\t\t| MatIconAnchor\r\n\t\t| MatFabButton\r\n\t\t| MatFabAnchor\r\n\t\t| MatMiniFabButton\r\n\t\t| MatMiniFabAnchor\r\n\t\t| undefined;\r\n\r\n\tconstructor(\r\n\t\tprivate readonly _eRef: ElementRef<HTMLElement>,\r\n\t\t@Optional() readonly _button: MatButton,\r\n\t\t@Optional() readonly _iconButton: MatIconButton,\r\n\t\t@Optional() readonly _iconAnchor: MatIconAnchor,\r\n\t\t@Optional() readonly _fab: MatFabButton,\r\n\t\t@Optional() readonly _fabAnchor: MatFabAnchor,\r\n\t\t@Optional() readonly _miniFab: MatMiniFabButton,\r\n\t\t@Optional() readonly _miniFabAnchor: MatMiniFabAnchor,\r\n\t\t@Inject(DOCUMENT) private readonly doc: Document,\r\n\t\tprivate _viewCont: ViewContainerRef\r\n\t) {\r\n\t\tthis.button = _button || _iconButton || _iconAnchor || _fab || _fabAnchor || _miniFab || _miniFabAnchor;\r\n\t\tif (!this.button) {\r\n\t\t\tconsole.error('[buiAwait] can only be used on a Material button.');\r\n\t\t\treturn;\r\n\t\t}\r\n\t}\r\n\r\n\t/** @ignore */\r\n\tngAfterViewInit(): void {\r\n\t\tif (this.button) {\r\n\t\t\tthis._overlayEl = this.doc.createElement('div');\r\n\t\t\tthis._eRef.nativeElement.appendChild(this._overlayEl);\r\n\t\t\tthis._overlayEl.classList.add('bui-await-overlay');\r\n\t\t\tthis._overlayEl.style.cssText =\r\n\t\t\t\t'display:flex; position:absolute; top:0; right:0; bottom:0; left:0; align-items: center; justify-content: center';\r\n\t\t\tthis._captionWrapper = this._eRef.nativeElement.querySelector('.mdc-button__label,.mat-icon') as HTMLElement;\r\n\t\t}\r\n\t}\r\n\r\n\t/** @ignore */\r\n\tngDoCheck(): void {\r\n\t\tconst inProgress =\r\n\t\t\tthis.buiAwait === true || (typeof this.buiAwait === 'object' && !this.buiAwait!.closed) || this._isDeterminate;\r\n\t\tif (inProgress !== this._processing) {\r\n\t\t\tthis._processing = inProgress;\r\n\t\t\tthis._statusChanged(this._isDeterminate ? 'determinate' : 'indeterminate');\r\n\t\t}\r\n\t\tif (this._isDeterminate && this._spinnerRef) {\r\n\t\t\tthis._spinnerRef.setInput('value', this.buiAwait);\r\n\t\t}\r\n\t}\r\n\r\n\t/** @ignore */\r\n\tprivate get _isDeterminate(): boolean {\r\n\t\treturn typeof this.buiAwait === 'number' && this.buiAwait >= 0 && this.buiAwait < 100;\r\n\t}\r\n\r\n\tprivate _statusChanged(mode: ProgressSpinnerMode) {\r\n\t\tif (this.button) {\r\n\t\t\tthis.button.disabled = this._processing;\r\n\r\n\t\t\tif (this._processing) {\r\n\t\t\t\tthis._spinnerRef = this._viewCont.createComponent(MatProgressSpinner);\r\n\t\t\t\tconst c = this._spinnerRef.instance;\r\n\t\t\t\tc.diameter = this.buiAwaitDiameter;\r\n\t\t\t\tc.mode = mode;\r\n\t\t\t\tc.color = this.button.color;\r\n\t\t\t\tconst e: HTMLElement = this._spinnerRef.location.nativeElement;\r\n\t\t\t\te.setAttribute('aria-label', this.buiAwaitAriaLabel);\r\n\t\t\t\tthis._overlayEl!.appendChild(e);\r\n\t\t\t\tthis._captionWrapper!.style.visibility = 'hidden';\r\n\t\t\t} else {\r\n\t\t\t\tthis._captionWrapper!.style.visibility = '';\r\n\t\t\t\tthis._spinnerRef!.destroy();\r\n\t\t\t\tthis._spinnerRef = undefined;\r\n\t\t\t\tthis._overlayEl!.innerHTML = '';\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}\r\n"]}

package/esm2022/behavior/behavior.module.mjs

@@ -0,0 +1,37 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SizingDirective } from './sizing.directive';
+import { SizingMonitorDirective } from './sizing-monitor.directive';
+import { AwaitDirective } from './await.directive';
+import { MatButtonModule } from '@angular/material/button';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { ObserveContentClassDirective } from './observe-content-class.directive';
+import { ObserversModule } from '@angular/cdk/observers';
+import * as i0 from "@angular/core";
+/**
+ *  For functionality that cannot be easily achieved via CSS.
+ */
+export class BehaviorModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: BehaviorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.2", ngImport: i0, type: BehaviorModule, declarations: [SizingDirective, SizingMonitorDirective, AwaitDirective, ObserveContentClassDirective], imports: [CommonModule, MatButtonModule, MatProgressSpinnerModule, ObserversModule], exports: [SizingDirective,
+            SizingMonitorDirective,
+            AwaitDirective,
+            MatProgressSpinnerModule,
+            ObserveContentClassDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: BehaviorModule, imports: [CommonModule, MatButtonModule, MatProgressSpinnerModule, ObserversModule, MatProgressSpinnerModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: BehaviorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SizingDirective, SizingMonitorDirective, AwaitDirective, ObserveContentClassDirective],
+                    imports: [CommonModule, MatButtonModule, MatProgressSpinnerModule, ObserversModule],
+                    exports: [
+                        SizingDirective,
+                        SizingMonitorDirective,
+                        AwaitDirective,
+                        MatProgressSpinnerModule,
+                        ObserveContentClassDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/behavior/observe-content-class.directive.mjs

@@ -0,0 +1,63 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/observers";
+/**
+ * Use `[bui-class.not-empty]` to specify a style class activated only when the host element has DOM children;
+ *
+ * use `[bui-class.empty]` for a style class activated when it has no DOM children.
+ *
+ * Use `[bui-class.no-text]` to specify a style class activated only when the host element has text content;
+ *
+ * use `[bui-class.has-text]` for a style class activated when it has no text content.
+ */
+export class ObserveContentClassDirective {
+    constructor(observer, elementRef) {
+        this.classToRemove = [];
+        this.element = elementRef.nativeElement;
+        this.subscription = observer.observe(elementRef).subscribe(() => this.checkClass());
+    }
+    ngOnInit() {
+        this.checkClass.bind(this);
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    checkClass() {
+        this.element.classList.remove(...this.classToRemove);
+        this.classToRemove = [];
+        this.checkClassWith(this.classEmpty, this.classNotEmpty, () => this.element.childElementCount === 0 && !this.element.textContent?.trim());
+        this.checkClassWith(this.classNoText, this.classHasText, () => !this.element.textContent?.trim());
+    }
+    checkClassWith(withoutClass, withClass, isWithout) {
+        const without = isWithout();
+        this.addClass(without ? withoutClass : withClass);
+    }
+    addClass(cls) {
+        if (cls?.trim()) {
+            const classes = cls.trim().split(/\s+/);
+            this.element.classList.add(...classes);
+            this.classToRemove.push(...classes);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ObserveContentClassDirective, deps: [{ token: i1.ContentObserver }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: ObserveContentClassDirective, selector: "[bui-class.empty],[bui-class.not-empty],[bui-class.no-text],[bui-class.has-text]", inputs: { classEmpty: ["bui-class.empty", "classEmpty"], classNotEmpty: ["bui-class.not-empty", "classNotEmpty"], classNoText: ["bui-class.no-text", "classNoText"], classHasText: ["bui-class.has-text", "classHasText"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ObserveContentClassDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bui-class.empty],[bui-class.not-empty],[bui-class.no-text],[bui-class.has-text]'
+                }]
+        }], ctorParameters: () => [{ type: i1.ContentObserver }, { type: i0.ElementRef }], propDecorators: { classEmpty: [{
+                type: Input,
+                args: ['bui-class.empty']
+            }], classNotEmpty: [{
+                type: Input,
+                args: ['bui-class.not-empty']
+            }], classNoText: [{
+                type: Input,
+                args: ['bui-class.no-text']
+            }], classHasText: [{
+                type: Input,
+                args: ['bui-class.has-text']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/behavior/public-api.mjs

@@ -3,4 +3,4 @@ export * from './sizing-monitor.directive';
 export * from './behavior.module';
 export * from './await.directive';
 export * from './observe-content-class.directive';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL2JlaGF2aW9yL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zaXppbmcuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc2l6aW5nLW1vbml0b3IuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYmVoYXZpb3IubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vYXdhaXQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vb2JzZXJ2ZS1jb250ZW50LWNsYXNzLmRpcmVjdGl2ZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL2JlaGF2aW9yL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zaXppbmcuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zaXppbmctbW9uaXRvci5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2JlaGF2aW9yLm1vZHVsZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYXdhaXQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9vYnNlcnZlLWNvbnRlbnQtY2xhc3MuZGlyZWN0aXZlJztcclxuIl19

package/esm2022/behavior/sizing-monitor.directive.mjs

@@ -0,0 +1,31 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Use this directive to designate a target HTML element, based on which the child elements'
+ * `[buiSizing]` directives will calculate the sizes.
+ *
+ * ```html
+ * <div [buiSizingMonitor]>
+ *    <div [buiSizing]="...">
+ *    </div>
+ *    <div>
+ *       <div [buiSizing]="...">
+ *       </div>
+ *    </div>
+ * <div>
+ * ```
+ */
+export class SizingMonitorDirective {
+    constructor(element) {
+        this.element = element;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: SizingMonitorDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: SizingMonitorDirective, selector: "[buiSizingMonitor]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: SizingMonitorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[buiSizingMonitor]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2l6aW5nLW1vbml0b3IuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvYmVoYXZpb3Ivc2l6aW5nLW1vbml0b3IuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWMsTUFBTSxlQUFlLENBQUM7O0FBRXREOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBSUgsTUFBTSxPQUFPLHNCQUFzQjtJQUNsQyxZQUE0QixPQUFnQztRQUFoQyxZQUFPLEdBQVAsT0FBTyxDQUF5QjtJQUFHLENBQUM7OEdBRHBELHNCQUFzQjtrR0FBdEIsc0JBQXNCOzsyRkFBdEIsc0JBQXNCO2tCQUhsQyxTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxvQkFBb0I7aUJBQzlCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG4vKipcclxuICogVXNlIHRoaXMgZGlyZWN0aXZlIHRvIGRlc2lnbmF0ZSBhIHRhcmdldCBIVE1MIGVsZW1lbnQsIGJhc2VkIG9uIHdoaWNoIHRoZSBjaGlsZCBlbGVtZW50cydcclxuICogYFtidWlTaXppbmddYCBkaXJlY3RpdmVzIHdpbGwgY2FsY3VsYXRlIHRoZSBzaXplcy5cclxuICpcclxuICogYGBgaHRtbFxyXG4gKiA8ZGl2IFtidWlTaXppbmdNb25pdG9yXT5cclxuICogICAgPGRpdiBbYnVpU2l6aW5nXT1cIi4uLlwiPlxyXG4gKiAgICA8L2Rpdj5cclxuICogICAgPGRpdj5cclxuICogICAgICAgPGRpdiBbYnVpU2l6aW5nXT1cIi4uLlwiPlxyXG4gKiAgICAgICA8L2Rpdj5cclxuICogICAgPC9kaXY+XHJcbiAqIDxkaXY+XHJcbiAqIGBgYFxyXG4gKi9cclxuQERpcmVjdGl2ZSh7XHJcblx0c2VsZWN0b3I6ICdbYnVpU2l6aW5nTW9uaXRvcl0nXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTaXppbmdNb25pdG9yRGlyZWN0aXZlIHtcclxuXHRjb25zdHJ1Y3RvcihwdWJsaWMgcmVhZG9ubHkgZWxlbWVudDogRWxlbWVudFJlZjxIVE1MRWxlbWVudD4pIHt9XHJcbn1cclxuIl19

package/esm2022/behavior/sizing.directive.mjs

@@ -0,0 +1,256 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { DOCUMENT } from '@angular/common';
+import { Directive, EventEmitter, Inject, Input, Optional, Output } from '@angular/core';
+import { debounceTime, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./sizing-monitor.directive";
+/**
+ * This directive monitors the changes in the width of the `sizingBy` target, and apply specified style
+ *  classes and/or inline styles to the current element dynamically.
+ *
+ * In order for the layout engine to efficiently calculate and stabilize the dimensions, the effective style property
+ * `box-sizing` of the `sizingBy` target element must be set to `border-box`.
+ *
+ * The directive uses [ResizeObserver API](https://developer.mozilla.org/en-US/docs/Web/API/Resize_Observer_API)
+ * to capture the events of element resizing. Please use a polyfill if you want to support older browsers
+ * that do not implement ResizeObserver API.
+ *
+ * Examples:
+ *
+ * ```html
+ * <div #parentElement>
+ *   <div [buiSizing]="{'400': 'small', '800': 'medium', '~': 'large'}" [buiSizingBy]="parentElement"></div>
+ *   <div [buiSizing]="['small', 'medium', 'large']" [buiSizingBy]="'root'"></div>
+ *   <div [buiSizing]="{'650': 'border-color: #28569', '~': 'bg-muted; border-style: dotted'}" [buiSizingBy]="parentElement"></div>
+ * </div>
+ * ```
+ */
+export class SizingDirective {
+    /**
+     * @ignore
+     */
+    static { this.defaultSizingBreakpoints = ['400', '800', '~']; }
+    /**
+     * Designate an element to be monitored for recalculating the style classes of the current element.
+     *
+     * - `root` specifies the document root or the enclosing shadow host. This is the default value.
+     * - `parent` specifies the parent element.
+     *
+     * @default 'root'
+     * @alias sizingBy
+     */
+    get buiSizingBy() {
+        return this.sizingBy;
+    }
+    set buiSizingBy(target) {
+        this.sizingBy = target;
+    }
+    constructor(_doc, _defaultTarget, elemRef, _zone) {
+        this._doc = _doc;
+        this._defaultTarget = _defaultTarget;
+        this._zone = _zone;
+        /**
+         * Specifies the breakpoint widths and the style classes.
+         *
+         * The sizing spec `{"400": "small", "800": "medium", "~": "large"}` tells the directive to apply
+         * a style class `small` when the width of the monitored target is smaller than 400 pixels,
+         * `medium` when the width is between 400 and 800 pixels, and `large` when above.
+         *
+         * @example {'400': 'small', '800': 'medium', '~': 'large'}
+         */
+        this.buiSizing = {};
+        /**
+         * The alias of `buiSizingBy`.
+         * @default 'root'
+         * @deprecated
+         * @ignore
+         */
+        this.sizingBy = 'root';
+        /**
+         * Emits `{width, height}` when the monitor target element resizes.
+         *
+         * Note that the dimensions emitted are of the [sizingBy] target, but not the current element.
+         */
+        this.buiResized = new EventEmitter();
+        /**
+         * Recalculate the height of this element according to the height of the monitored target.
+         */
+        this.buiFixedHeight = false;
+        this._sizingSpec = {};
+        this._width = 0;
+        this._height = 0;
+        this._reflowFrameCount = 0;
+        this._frameHandlerId = 0;
+        this._element = elemRef.nativeElement;
+        this._monitorTarget = this._element;
+    }
+    ngOnChanges(_) {
+        const disconnected = this._element.getRootNode() instanceof HTMLElement;
+        if (disconnected) {
+            // defer shadow detection till dom connection event
+            this._zone.onStable.pipe(debounceTime(10), take(1)).subscribe(() => this._initOrReset());
+        }
+        else {
+            this._initOrReset();
+        }
+    }
+    ngOnDestroy() {
+        this._tearDownNodeMonitor();
+    }
+    _initOrReset() {
+        const originalTarget = this._monitorTarget;
+        if (this.buiSizingBy instanceof HTMLElement) {
+            this._monitorTarget = this.buiSizingBy;
+        }
+        else if (this._defaultTarget) {
+            this._monitorTarget = this._defaultTarget.element.nativeElement;
+        }
+        else if (this.buiSizingBy === 'root') {
+            const root = this._element.getRootNode();
+            if (root instanceof ShadowRoot) {
+                this._monitorTarget = root.host;
+            }
+            else {
+                this._monitorTarget = this._doc.documentElement;
+            }
+        }
+        else {
+            this._monitorTarget = this._element.parentElement;
+        }
+        if (this._monitorTarget != originalTarget) {
+            this._setUpNodeMonitor();
+        }
+        this._sizingSpec = {};
+        let spec = this.buiSizing;
+        if (typeof spec === 'string') {
+            spec = spec.split(',').map(k => k.trim());
+        }
+        if (Array.isArray(spec)) {
+            spec.forEach((c, i) => {
+                this._sizingSpec[SizingDirective.defaultSizingBreakpoints[i] || '~'] = c;
+            });
+        }
+        else if (spec) {
+            this._sizingSpec = spec;
+        }
+        this.buiFixedHeight = coerceBooleanProperty(this.buiFixedHeight);
+        this._calculateSize();
+    }
+    _setUpNodeMonitor() {
+        this._tearDownNodeMonitor();
+        if (this._monitorTarget) {
+            this._observer = new ResizeObserver(() => this._runWithObserver(this._calculateSize.bind(this)));
+            this._observer.observe(this._monitorTarget, { box: 'border-box' });
+        }
+    }
+    _tearDownNodeMonitor() {
+        cancelAnimationFrame(this._frameHandlerId);
+        this._runWithObserver(() => {
+            this._observer.disconnect();
+            this._observer = undefined;
+        });
+    }
+    _runWithObserver(func) {
+        if (this._observer) {
+            return func();
+        }
+        return undefined;
+    }
+    _calculateSize() {
+        const widthChanged = this._width !== this._monitorTarget.clientWidth;
+        const heightChanged = this._height !== this._monitorTarget.clientHeight;
+        if (widthChanged) {
+            this._width = this._monitorTarget.clientWidth;
+            const bks = Object.keys(this._sizingSpec).sort((a, b) => this._toNumber(a) - this._toNumber(b));
+            let found = false;
+            for (const key of bks) {
+                const classesOrStyles = this._sizingSpec[key].split(/;+/).filter(c => c);
+                this._removeClassesOrStyles(classesOrStyles);
+                const expectedWidth = this._toNumber(key);
+                if (this._width <= expectedWidth && !found) {
+                    this._applyClassesOrStyles(classesOrStyles);
+                    found = true;
+                }
+            }
+        }
+        if (widthChanged || heightChanged) {
+            this._height = this._monitorTarget.clientHeight;
+            if (this.buiFixedHeight) {
+                this._reflowFrameCount = 0;
+                this._reflowHeight();
+            }
+            setTimeout(() => this._zone.run(() => this.buiResized.emit({ width: this._width, height: this._height })));
+        }
+    }
+    _applyClassesOrStyles(clsOrStyles) {
+        clsOrStyles.forEach(s => {
+            if (s.includes(':')) {
+                const [prop, val] = s.split(':');
+                this._element.style.setProperty(prop.trim(), val.trim());
+            }
+            else {
+                const classes = s.split(/\s+/).filter(c => c);
+                if (classes.length) {
+                    this._element.classList.add(...classes);
+                }
+            }
+        });
+    }
+    _removeClassesOrStyles(clsOrStyles) {
+        clsOrStyles.forEach(s => {
+            if (s.includes(':')) {
+                const [prop] = s.split(':');
+                this._element.style.removeProperty(prop);
+            }
+            else {
+                const classes = s.split(/\s+/).filter(c => c);
+                if (classes.length) {
+                    this._element.classList.remove(...classes);
+                }
+            }
+        });
+    }
+    _reflowHeight() {
+        const cnt = this._reflowFrameCount;
+        if (cnt < 15) {
+            cancelAnimationFrame(this._frameHandlerId);
+            this._frameHandlerId = requestAnimationFrame(this._reflowHeight.bind(this));
+            if (cnt === 0) {
+                this._element.style.height = '0';
+            }
+            else if (cnt === 14) {
+                const gt = parseInt(getComputedStyle(this._monitorTarget).getPropertyValue('padding-top').replace(/px$/, '') || '0', 10);
+                const gb = parseInt(getComputedStyle(this._monitorTarget).getPropertyValue('padding-bottom').replace(/px$/, '') || '0', 10);
+                this._element.style.height = `${this._height - gt - gb - 5}px`;
+            }
+        }
+        this._reflowFrameCount++;
+    }
+    _toNumber(s) {
+        return (s === '~' ? Infinity : Number(s)) || -Infinity;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: SizingDirective, deps: [{ token: DOCUMENT }, { token: i1.SizingMonitorDirective, optional: true }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: SizingDirective, selector: "[buiSizing],[buiResized],[buiSizingBy],[buiFixedHeight]", inputs: { buiSizing: "buiSizing", sizingBy: "sizingBy", buiSizingBy: "buiSizingBy", buiFixedHeight: "buiFixedHeight" }, outputs: { buiResized: "buiResized" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: SizingDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[buiSizing],[buiResized],[buiSizingBy],[buiFixedHeight]'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.SizingMonitorDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { buiSizing: [{
+                type: Input
+            }], sizingBy: [{
+                type: Input
+            }], buiSizingBy: [{
+                type: Input
+            }], buiResized: [{
+                type: Output
+            }], buiFixedHeight: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sizing.directive.js","sourceRoot":"","sources":["../../../../projects/ui/behavior/sizing.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport {\r\n\tDirective,\r\n\tElementRef,\r\n\tEventEmitter,\r\n\tInject,\r\n\tInput,\r\n\tNgZone,\r\n\tOnChanges,\r\n\tOnDestroy,\r\n\tOptional,\r\n\tOutput,\r\n\tSimpleChanges\r\n} from '@angular/core';\r\nimport { debounceTime, take } from 'rxjs/operators';\r\nimport { SizingMonitorDirective } from './sizing-monitor.directive';\r\n\r\n/**\r\n * This directive monitors the changes in the width of the `sizingBy` target, and apply specified style\r\n *  classes and/or inline styles to the current element dynamically.\r\n *\r\n * In order for the layout engine to efficiently calculate and stabilize the dimensions, the effective style property\r\n * `box-sizing` of the `sizingBy` target element must be set to `border-box`.\r\n *\r\n * The directive uses [ResizeObserver API](https://developer.mozilla.org/en-US/docs/Web/API/Resize_Observer_API)\r\n * to capture the events of element resizing. Please use a polyfill if you want to support older browsers\r\n * that do not implement ResizeObserver API.\r\n *\r\n * Examples:\r\n *\r\n * ```html\r\n * <div #parentElement>\r\n *   <div [buiSizing]=\"{'400': 'small', '800': 'medium', '~': 'large'}\" [buiSizingBy]=\"parentElement\"></div>\r\n *   <div [buiSizing]=\"['small', 'medium', 'large']\" [buiSizingBy]=\"'root'\"></div>\r\n *   <div [buiSizing]=\"{'650': 'border-color: #28569', '~': 'bg-muted; border-style: dotted'}\" [buiSizingBy]=\"parentElement\"></div>\r\n * </div>\r\n * ```\r\n */\r\n@Directive({\r\n\tselector: '[buiSizing],[buiResized],[buiSizingBy],[buiFixedHeight]'\r\n})\r\nexport class SizingDirective implements OnChanges, OnDestroy {\r\n\t/**\r\n\t * @ignore\r\n\t */\r\n\tstatic defaultSizingBreakpoints = ['400', '800', '~'];\r\n\r\n\t/**\r\n\t * Specifies the breakpoint widths and the style classes.\r\n\t *\r\n\t * The sizing spec `{\"400\": \"small\", \"800\": \"medium\", \"~\": \"large\"}` tells the directive to apply\r\n\t * a style class `small` when the width of the monitored target is smaller than 400 pixels,\r\n\t * `medium` when the width is between 400 and 800 pixels, and `large` when above.\r\n\t *\r\n\t * @example {'400': 'small', '800': 'medium', '~': 'large'}\r\n\t */\r\n\t@Input()\r\n\tbuiSizing: string | Array<string> | { [key: string]: string } = {};\r\n\r\n\t/**\r\n\t * The alias of `buiSizingBy`.\r\n\t * @default 'root'\r\n\t * @deprecated\r\n\t * @ignore\r\n\t */\r\n\t@Input()\r\n\tsizingBy: 'root' | 'parent' | HTMLElement = 'root';\r\n\r\n\t/**\r\n\t * Designate an element to be monitored for recalculating the style classes of the current element.\r\n\t *\r\n\t * - `root` specifies the document root or the enclosing shadow host. This is the default value.\r\n\t * - `parent` specifies the parent element.\r\n\t *\r\n\t * @default 'root'\r\n\t * @alias sizingBy\r\n\t */\r\n\t@Input()\r\n\tget buiSizingBy(): 'root' | 'parent' | HTMLElement {\r\n\t\treturn this.sizingBy;\r\n\t}\r\n\tset buiSizingBy(target: 'root' | 'parent' | HTMLElement) {\r\n\t\tthis.sizingBy = target;\r\n\t}\r\n\r\n\t/**\r\n\t * Emits `{width, height}` when the monitor target element resizes.\r\n\t *\r\n\t * Note that the dimensions emitted are of the [sizingBy] target, but not the current element.\r\n\t */\r\n\t@Output()\r\n\tbuiResized = new EventEmitter<{ width: number; height: number }>();\r\n\r\n\t/**\r\n\t * Recalculate the height of this element according to the height of the monitored target.\r\n\t */\r\n\t@Input()\r\n\tbuiFixedHeight = false;\r\n\r\n\tprivate _monitorTarget: HTMLElement;\r\n\tprivate _observer: ResizeObserver | undefined;\r\n\tprivate _sizingSpec: { [key: string]: string } = {};\r\n\tprivate _width = 0;\r\n\tprivate _height = 0;\r\n\tprivate _reflowFrameCount = 0;\r\n\tprivate _element: HTMLElement;\r\n\tprivate _frameHandlerId = 0;\r\n\r\n\tconstructor(\r\n\t\t@Inject(DOCUMENT) private _doc: Document,\r\n\t\t@Optional() private _defaultTarget: SizingMonitorDirective,\r\n\t\telemRef: ElementRef<HTMLElement>,\r\n\t\tprivate _zone: NgZone\r\n\t) {\r\n\t\tthis._element = elemRef.nativeElement;\r\n\t\tthis._monitorTarget = this._element;\r\n\t}\r\n\r\n\tngOnChanges(_: SimpleChanges): void {\r\n\t\tconst disconnected = this._element.getRootNode() instanceof HTMLElement;\r\n\t\tif (disconnected) {\r\n\t\t\t// defer shadow detection till dom connection event\r\n\t\t\tthis._zone.onStable.pipe(debounceTime(10), take(1)).subscribe(() => this._initOrReset());\r\n\t\t} else {\r\n\t\t\tthis._initOrReset();\r\n\t\t}\r\n\t}\r\n\r\n\tngOnDestroy(): void {\r\n\t\tthis._tearDownNodeMonitor();\r\n\t}\r\n\r\n\tprivate _initOrReset() {\r\n\t\tconst originalTarget = this._monitorTarget;\r\n\t\tif (this.buiSizingBy instanceof HTMLElement) {\r\n\t\t\tthis._monitorTarget = this.buiSizingBy;\r\n\t\t} else if (this._defaultTarget) {\r\n\t\t\tthis._monitorTarget = this._defaultTarget.element.nativeElement;\r\n\t\t} else if (this.buiSizingBy === 'root') {\r\n\t\t\tconst root = this._element.getRootNode();\r\n\t\t\tif (root instanceof ShadowRoot) {\r\n\t\t\t\tthis._monitorTarget = root.host as HTMLElement;\r\n\t\t\t} else {\r\n\t\t\t\tthis._monitorTarget = this._doc.documentElement;\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tthis._monitorTarget = this._element.parentElement as any;\r\n\t\t}\r\n\r\n\t\tif (this._monitorTarget != originalTarget) {\r\n\t\t\tthis._setUpNodeMonitor();\r\n\t\t}\r\n\r\n\t\tthis._sizingSpec = {};\r\n\t\tlet spec = this.buiSizing;\r\n\t\tif (typeof spec === 'string') {\r\n\t\t\tspec = spec.split(',').map(k => k.trim());\r\n\t\t}\r\n\r\n\t\tif (Array.isArray(spec)) {\r\n\t\t\tspec.forEach((c, i) => {\r\n\t\t\t\tthis._sizingSpec[SizingDirective.defaultSizingBreakpoints[i] || '~'] = c;\r\n\t\t\t});\r\n\t\t} else if (spec) {\r\n\t\t\tthis._sizingSpec = spec;\r\n\t\t}\r\n\r\n\t\tthis.buiFixedHeight = coerceBooleanProperty(this.buiFixedHeight);\r\n\r\n\t\tthis._calculateSize();\r\n\t}\r\n\r\n\tprivate _setUpNodeMonitor() {\r\n\t\tthis._tearDownNodeMonitor();\r\n\t\tif (this._monitorTarget) {\r\n\t\t\tthis._observer = new ResizeObserver(() => this._runWithObserver(this._calculateSize.bind(this)));\r\n\r\n\t\t\tthis._observer.observe(this._monitorTarget, { box: 'border-box' });\r\n\t\t}\r\n\t}\r\n\r\n\tprivate _tearDownNodeMonitor() {\r\n\t\tcancelAnimationFrame(this._frameHandlerId);\r\n\t\tthis._runWithObserver(() => {\r\n\t\t\tthis._observer!.disconnect();\r\n\t\t\tthis._observer = undefined;\r\n\t\t});\r\n\t}\r\n\r\n\tprivate _runWithObserver<T>(func: () => T): T | undefined {\r\n\t\tif (this._observer) {\r\n\t\t\treturn func();\r\n\t\t}\r\n\t\treturn undefined;\r\n\t}\r\n\r\n\tprivate _calculateSize() {\r\n\t\tconst widthChanged = this._width !== this._monitorTarget.clientWidth;\r\n\t\tconst heightChanged = this._height !== this._monitorTarget.clientHeight;\r\n\t\tif (widthChanged) {\r\n\t\t\tthis._width = this._monitorTarget.clientWidth;\r\n\r\n\t\t\tconst bks = Object.keys(this._sizingSpec).sort((a, b) => this._toNumber(a) - this._toNumber(b));\r\n\t\t\tlet found = false;\r\n\t\t\tfor (const key of bks) {\r\n\t\t\t\tconst classesOrStyles = this._sizingSpec[key].split(/;+/).filter(c => c);\r\n\t\t\t\tthis._removeClassesOrStyles(classesOrStyles);\r\n\t\t\t\tconst expectedWidth = this._toNumber(key);\r\n\t\t\t\tif (this._width <= expectedWidth && !found) {\r\n\t\t\t\t\tthis._applyClassesOrStyles(classesOrStyles);\r\n\t\t\t\t\tfound = true;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (widthChanged || heightChanged) {\r\n\t\t\tthis._height = this._monitorTarget.clientHeight;\r\n\t\t\tif (this.buiFixedHeight) {\r\n\t\t\t\tthis._reflowFrameCount = 0;\r\n\t\t\t\tthis._reflowHeight();\r\n\t\t\t}\r\n\t\t\tsetTimeout(() => this._zone.run(() => this.buiResized.emit({ width: this._width, height: this._height })));\r\n\t\t}\r\n\t}\r\n\r\n\tprivate _applyClassesOrStyles(clsOrStyles: string[]) {\r\n\t\tclsOrStyles.forEach(s => {\r\n\t\t\tif (s.includes(':')) {\r\n\t\t\t\tconst [prop, val] = s.split(':');\r\n\t\t\t\tthis._element.style.setProperty(prop.trim(), val.trim());\r\n\t\t\t} else {\r\n\t\t\t\tconst classes = s.split(/\\s+/).filter(c => c);\r\n\t\t\t\tif (classes.length) {\r\n\t\t\t\t\tthis._element.classList.add(...classes);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tprivate _removeClassesOrStyles(clsOrStyles: string[]) {\r\n\t\tclsOrStyles.forEach(s => {\r\n\t\t\tif (s.includes(':')) {\r\n\t\t\t\tconst [prop] = s.split(':');\r\n\t\t\t\tthis._element.style.removeProperty(prop);\r\n\t\t\t} else {\r\n\t\t\t\tconst classes = s.split(/\\s+/).filter(c => c);\r\n\t\t\t\tif (classes.length) {\r\n\t\t\t\t\tthis._element.classList.remove(...classes);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tprivate _reflowHeight() {\r\n\t\tconst cnt = this._reflowFrameCount;\r\n\t\tif (cnt < 15) {\r\n\t\t\tcancelAnimationFrame(this._frameHandlerId);\r\n\t\t\tthis._frameHandlerId = requestAnimationFrame(this._reflowHeight.bind(this));\r\n\r\n\t\t\tif (cnt === 0) {\r\n\t\t\t\tthis._element.style.height = '0';\r\n\t\t\t} else if (cnt === 14) {\r\n\t\t\t\tconst gt = parseInt(\r\n\t\t\t\t\tgetComputedStyle(this._monitorTarget).getPropertyValue('padding-top').replace(/px$/, '') || '0',\r\n\t\t\t\t\t10\r\n\t\t\t\t);\r\n\t\t\t\tconst gb = parseInt(\r\n\t\t\t\t\tgetComputedStyle(this._monitorTarget).getPropertyValue('padding-bottom').replace(/px$/, '') || '0',\r\n\t\t\t\t\t10\r\n\t\t\t\t);\r\n\t\t\t\tthis._element.style.height = `${this._height - gt - gb - 5}px`;\r\n\t\t\t}\r\n\t\t}\r\n\t\tthis._reflowFrameCount++;\r\n\t}\r\n\r\n\tprivate _toNumber(s: string) {\r\n\t\treturn (s === '~' ? Infinity : Number(s)) || -Infinity;\r\n\t}\r\n}\r\n"]}