@design-factory/design-factory 15.2.0

package/esm2022/lib/angular/progressindicator/progressindicator-backdrop.component.mjs

@@ -0,0 +1,29 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DfProgressIndicatorBackdropComponent {
+    constructor() {
+        this.isGlobalBackdrop = true;
+    }
+    get classes() {
+        return `df-progressindicator-backdrop ${this.backdropClass || ''} ${this.isGlobalBackdrop ? 'df-progressindicator-backdrop-global' : 'df-progressindicator-backdrop-contextual'}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorBackdropComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: DfProgressIndicatorBackdropComponent, isStandalone: true, selector: "df-progressindicator-backdrop", inputs: { backdropClass: "backdropClass", isGlobalBackdrop: "isGlobalBackdrop" }, host: { properties: { "class": "this.classes" } }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorBackdropComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'df-progressindicator-backdrop',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }], propDecorators: { classes: [{
+                type: HostBinding,
+                args: ['class']
+            }], backdropClass: [{
+                type: Input
+            }], isGlobalBackdrop: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3NpbmRpY2F0b3ItYmFja2Ryb3AuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGVzaWduLWZhY3Rvcnkvc3JjL2xpYi9hbmd1bGFyL3Byb2dyZXNzaW5kaWNhdG9yL3Byb2dyZXNzaW5kaWNhdG9yLWJhY2tkcm9wLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBUXZGLE1BQU0sT0FBTyxvQ0FBb0M7SUFOakQ7UUFhVyxxQkFBZ0IsR0FBRyxJQUFJLENBQUM7S0FDbEM7SUFQQyxJQUEwQixPQUFPO1FBQy9CLE9BQU8saUNBQWlDLElBQUksQ0FBQyxhQUFhLElBQUksRUFBRSxJQUM5RCxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLHNDQUFzQyxDQUFDLENBQUMsQ0FBQywwQ0FDbkUsRUFBRSxDQUFDO0lBQ0wsQ0FBQzs4R0FMVSxvQ0FBb0M7a0dBQXBDLG9DQUFvQyw4TkFKckMsRUFBRTs7MkZBSUQsb0NBQW9DO2tCQU5oRCxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSwrQkFBK0I7b0JBQ3pDLFFBQVEsRUFBRSxFQUFFO29CQUNaLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO29CQUMvQyxVQUFVLEVBQUUsSUFBSTtpQkFDakI7OEJBRTJCLE9BQU87c0JBQWhDLFdBQVc7dUJBQUMsT0FBTztnQkFLWCxhQUFhO3NCQUFyQixLQUFLO2dCQUNHLGdCQUFnQjtzQkFBeEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIEhvc3RCaW5kaW5nLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdkZi1wcm9ncmVzc2luZGljYXRvci1iYWNrZHJvcCcsXG4gIHRlbXBsYXRlOiAnJyxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG4gIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgRGZQcm9ncmVzc0luZGljYXRvckJhY2tkcm9wQ29tcG9uZW50IHtcbiAgQEhvc3RCaW5kaW5nKCdjbGFzcycpIGdldCBjbGFzc2VzKCkge1xuICAgIHJldHVybiBgZGYtcHJvZ3Jlc3NpbmRpY2F0b3ItYmFja2Ryb3AgJHt0aGlzLmJhY2tkcm9wQ2xhc3MgfHwgJyd9ICR7XG4gICAgICB0aGlzLmlzR2xvYmFsQmFja2Ryb3AgPyAnZGYtcHJvZ3Jlc3NpbmRpY2F0b3ItYmFja2Ryb3AtZ2xvYmFsJyA6ICdkZi1wcm9ncmVzc2luZGljYXRvci1iYWNrZHJvcC1jb250ZXh0dWFsJ1xuICAgIH1gO1xuICB9XG4gIEBJbnB1dCgpIGJhY2tkcm9wQ2xhc3M/OiBzdHJpbmc7XG4gIEBJbnB1dCgpIGlzR2xvYmFsQmFja2Ryb3AgPSB0cnVlO1xufVxuIl19

package/esm2022/lib/angular/progressindicator/progressindicator-config.mjs

@@ -0,0 +1,25 @@
+export var DfProgressIndicatorContentType;
+(function (DfProgressIndicatorContentType) {
+    DfProgressIndicatorContentType["SPINNER"] = "spinner";
+    DfProgressIndicatorContentType["PROGRESSBAR"] = "progressbar";
+})(DfProgressIndicatorContentType || (DfProgressIndicatorContentType = {}));
+export class DfProgressIndicatorContentSpinner {
+    constructor(spinnerInput) {
+        this.type = DfProgressIndicatorContentType.SPINNER;
+        this.spinnerInput = spinnerInput;
+    }
+}
+export class DfProgressIndicatorContentProgressBar {
+    constructor(progressBarInput, position) {
+        this.type = DfProgressIndicatorContentType.PROGRESSBAR;
+        this.progressBarInput = progressBarInput;
+        this.position = position || DfProgressIndicatorContentPosition.TOP;
+    }
+}
+export var DfProgressIndicatorContentPosition;
+(function (DfProgressIndicatorContentPosition) {
+    DfProgressIndicatorContentPosition["TOP"] = "top";
+    DfProgressIndicatorContentPosition["BOTTOM"] = "bottom";
+    DfProgressIndicatorContentPosition["CENTERED"] = "centered";
+})(DfProgressIndicatorContentPosition || (DfProgressIndicatorContentPosition = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3NpbmRpY2F0b3ItY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGVzaWduLWZhY3Rvcnkvc3JjL2xpYi9hbmd1bGFyL3Byb2dyZXNzaW5kaWNhdG9yL3Byb2dyZXNzaW5kaWNhdG9yLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE2QkEsTUFBTSxDQUFOLElBQVksOEJBR1g7QUFIRCxXQUFZLDhCQUE4QjtJQUN4QyxxREFBbUIsQ0FBQTtJQUNuQiw2REFBMkIsQ0FBQTtBQUM3QixDQUFDLEVBSFcsOEJBQThCLEtBQTlCLDhCQUE4QixRQUd6QztBQUVELE1BQU0sT0FBTyxpQ0FBaUM7SUFPNUMsWUFBWSxZQUE0RDtRQU4vRCxTQUFJLEdBQUcsOEJBQThCLENBQUMsT0FBTyxDQUFDO1FBT3JELElBQUksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDO0lBQ25DLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyxxQ0FBcUM7SUFPaEQsWUFBWSxnQkFBd0MsRUFBRSxRQUE2QztRQU4xRixTQUFJLEdBQUcsOEJBQThCLENBQUMsV0FBVyxDQUFDO1FBT3pELElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxnQkFBZ0IsQ0FBQztRQUN6QyxJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsSUFBSSxrQ0FBa0MsQ0FBQyxHQUFHLENBQUM7SUFDckUsQ0FBQztDQUNGO0FBRUQsTUFBTSxDQUFOLElBQVksa0NBSVg7QUFKRCxXQUFZLGtDQUFrQztJQUM1QyxpREFBVyxDQUFBO0lBQ1gsdURBQWlCLENBQUE7SUFDakIsMkRBQXFCLENBQUE7QUFDdkIsQ0FBQyxFQUpXLGtDQUFrQyxLQUFsQyxrQ0FBa0MsUUFJN0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIERmUHJvZ3Jlc3NJbmRpY2F0b3JPcHRpb25zIHtcbiAgLyoqXG4gICAqIElmIGB0cnVlYCwgdGhlIGJhY2tkcm9wIGVsZW1lbnQgd2lsbCBiZSBjcmVhdGVkIGZvciBhIGdpdmVuIHByb2dyZXNzIGluZGljYXRvci5cbiAgICogRGVmYXVsdCB2YWx1ZSBpcyBgdHJ1ZWAuXG4gICAqL1xuICBiYWNrZHJvcD86IGJvb2xlYW47XG5cbiAgLyoqXG4gICAqIEEgc2VsZWN0b3Igc3BlY2lmeWluZyB0aGUgcHJvZ3Jlc3MgaW5kaWNhdG9yIGVsZW1lbnRzIHNob3VsZCBiZSBhcHBlbmRlZCB0by5cbiAgICogSWYgbm90IHNwZWNpZmllZCwgd2lsbCBiZSBgYm9keWAuXG4gICAqL1xuICBjb250YWluZXI/OiBzdHJpbmcgfCBIVE1MRWxlbWVudDtcblxuICAvKipcbiAgICogQSBjdXN0b20gY2xhc3MgdG8gYXBwZW5kIHRvIHRoZSBwcm9ncmVzcyBpbmRpY2F0b3IgY29udGFpbmVyLlxuICAgKi9cbiAgY29udGFpbmVyQ2xhc3M/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFNwZWNpZnkgdGhlIHBvc2l0aW9uIG9mIHRoZSBjb250ZW50IGluIHRoZSBjb250YWluZXIuXG4gICAqL1xuICBwb3NpdGlvbj86IERmUHJvZ3Jlc3NJbmRpY2F0b3JDb250ZW50UG9zaXRpb247XG5cbiAgLyoqXG4gICAqIEEgY3VzdG9tIGNsYXNzIHRvIGFwcGVuZCB0byB0aGUgcHJvZ3Jlc3MgaW5kaWNhdG9yIGJhY2tkcm9wLlxuICAgKi9cbiAgYmFja2Ryb3BDbGFzcz86IHN0cmluZztcbn1cblxuZXhwb3J0IGVudW0gRGZQcm9ncmVzc0luZGljYXRvckNvbnRlbnRUeXBlIHtcbiAgU1BJTk5FUiA9ICdzcGlubmVyJyxcbiAgUFJPR1JFU1NCQVIgPSAncHJvZ3Jlc3NiYXInXG59XG5cbmV4cG9ydCBjbGFzcyBEZlByb2dyZXNzSW5kaWNhdG9yQ29udGVudFNwaW5uZXIge1xuICByZWFkb25seSB0eXBlID0gRGZQcm9ncmVzc0luZGljYXRvckNvbnRlbnRUeXBlLlNQSU5ORVI7XG4gIHNwaW5uZXJJbnB1dD86IHtcbiAgICBjb250ZW50Q2xhc3M/OiBzdHJpbmc7XG4gICAgYXJpYUxhYmVsPzogc3RyaW5nO1xuICB9O1xuXG4gIGNvbnN0cnVjdG9yKHNwaW5uZXJJbnB1dD86IHsgY29udGVudENsYXNzPzogc3RyaW5nOyBhcmlhTGFiZWw/OiBzdHJpbmcgfSkge1xuICAgIHRoaXMuc3Bpbm5lcklucHV0ID0gc3Bpbm5lcklucHV0O1xuICB9XG59XG5cbmV4cG9ydCBjbGFzcyBEZlByb2dyZXNzSW5kaWNhdG9yQ29udGVudFByb2dyZXNzQmFyIHtcbiAgcmVhZG9ubHkgdHlwZSA9IERmUHJvZ3Jlc3NJbmRpY2F0b3JDb250ZW50VHlwZS5QUk9HUkVTU0JBUjtcbiAgcHJvZ3Jlc3NCYXJJbnB1dD86IHtcbiAgICBhcmlhTGFiZWw6IHN0cmluZztcbiAgfTtcbiAgcG9zaXRpb246IERmUHJvZ3Jlc3NJbmRpY2F0b3JDb250ZW50UG9zaXRpb247XG5cbiAgY29uc3RydWN0b3IocHJvZ3Jlc3NCYXJJbnB1dD86IHsgYXJpYUxhYmVsOiBzdHJpbmcgfSwgcG9zaXRpb24/OiBEZlByb2dyZXNzSW5kaWNhdG9yQ29udGVudFBvc2l0aW9uKSB7XG4gICAgdGhpcy5wcm9ncmVzc0JhcklucHV0ID0gcHJvZ3Jlc3NCYXJJbnB1dDtcbiAgICB0aGlzLnBvc2l0aW9uID0gcG9zaXRpb24gfHwgRGZQcm9ncmVzc0luZGljYXRvckNvbnRlbnRQb3NpdGlvbi5UT1A7XG4gIH1cbn1cblxuZXhwb3J0IGVudW0gRGZQcm9ncmVzc0luZGljYXRvckNvbnRlbnRQb3NpdGlvbiB7XG4gIFRPUCA9ICd0b3AnLFxuICBCT1RUT00gPSAnYm90dG9tJyxcbiAgQ0VOVEVSRUQgPSAnY2VudGVyZWQnXG59XG4iXX0=

package/esm2022/lib/angular/progressindicator/progressindicator-container.component.mjs

@@ -0,0 +1,52 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+import { DfProgressIndicatorContentPosition } from './progressindicator-config';
+import * as i0 from "@angular/core";
+export class DfProgressIndicatorContainerComponent {
+    constructor() {
+        this.DEFAULT_CLASS_POSITION = 'df-progressindicator-centered';
+        this.positionClass = this.DEFAULT_CLASS_POSITION;
+    }
+    get classes() {
+        return `df-progressindicator-container ${this.containerClass || ''} ${this.positionClass}`;
+    }
+    set position(newPosition) {
+        switch (newPosition) {
+            case DfProgressIndicatorContentPosition.TOP:
+                this.positionClass = 'df-progressindicator-top';
+                break;
+            case DfProgressIndicatorContentPosition.BOTTOM:
+                this.positionClass = 'df-progressindicator-bottom';
+                break;
+            default:
+                this.positionClass = this.DEFAULT_CLASS_POSITION;
+        }
+        this._position = newPosition;
+    }
+    get position() {
+        return this._position;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: DfProgressIndicatorContainerComponent, isStandalone: true, selector: "df-progressindicator-container", inputs: { containerClass: "containerClass", position: "position" }, host: { properties: { "class": "this.classes" } }, ngImport: i0, template: `
+    <ng-content></ng-content>
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'df-progressindicator-container',
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <ng-content></ng-content>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }], propDecorators: { classes: [{
+                type: HostBinding,
+                args: ['class']
+            }], containerClass: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/progressindicator/progressindicator-ref.mjs

@@ -0,0 +1,8 @@
+export class DfProgressIndicatorRef {
+    constructor(containerRef, contentRef, backdropRef) {
+        this.containerRef = containerRef;
+        this.contentRef = contentRef;
+        this.backdropRef = backdropRef;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3NpbmRpY2F0b3ItcmVmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGVzaWduLWZhY3Rvcnkvc3JjL2xpYi9hbmd1bGFyL3Byb2dyZXNzaW5kaWNhdG9yL3Byb2dyZXNzaW5kaWNhdG9yLXJlZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLFlBQ1MsWUFBaUUsRUFDakUsVUFBNEQsRUFDNUQsV0FBZ0U7UUFGaEUsaUJBQVksR0FBWixZQUFZLENBQXFEO1FBQ2pFLGVBQVUsR0FBVixVQUFVLENBQWtEO1FBQzVELGdCQUFXLEdBQVgsV0FBVyxDQUFxRDtJQUN0RSxDQUFDO0NBQ0wiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnRSZWYsIEVtYmVkZGVkVmlld1JlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRGZQcm9ncmVzc0luZGljYXRvckJhY2tkcm9wQ29tcG9uZW50IH0gZnJvbSAnLi9wcm9ncmVzc2luZGljYXRvci1iYWNrZHJvcC5jb21wb25lbnQnO1xuaW1wb3J0IHsgRGZQcm9ncmVzc0luZGljYXRvckNvbnRhaW5lckNvbXBvbmVudCB9IGZyb20gJy4vcHJvZ3Jlc3NpbmRpY2F0b3ItY29udGFpbmVyLmNvbXBvbmVudCc7XG5cbmV4cG9ydCBjbGFzcyBEZlByb2dyZXNzSW5kaWNhdG9yUmVmIHtcbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIGNvbnRhaW5lclJlZjogQ29tcG9uZW50UmVmPERmUHJvZ3Jlc3NJbmRpY2F0b3JDb250YWluZXJDb21wb25lbnQ+LFxuICAgIHB1YmxpYyBjb250ZW50UmVmOiBDb21wb25lbnRSZWY8dW5rbm93bj4gfCBFbWJlZGRlZFZpZXdSZWY8dW5rbm93bj4sXG4gICAgcHVibGljIGJhY2tkcm9wUmVmPzogQ29tcG9uZW50UmVmPERmUHJvZ3Jlc3NJbmRpY2F0b3JCYWNrZHJvcENvbXBvbmVudD5cbiAgKSB7fVxufVxuIl19

package/esm2022/lib/angular/progressindicator/progressindicator.directive.mjs

@@ -0,0 +1,39 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./progressindicator.service";
+export class DfProgressIndicatorDirective {
+    constructor(elementRef, progressService) {
+        this.elementRef = elementRef;
+        this.progressService = progressService;
+    }
+    ngOnChanges(changes) {
+        if (changes['dfProgressIndicator']) {
+            const isProgressing = this.dfProgressIndicator;
+            if (isProgressing) {
+                const config = {
+                    ...this.dfProgressIndicatorConfig?.options,
+                    container: this.elementRef.nativeElement
+                };
+                this.progressIndicatorRef = this.progressService.open(this.dfProgressIndicatorConfig?.content, config);
+            }
+            else if (!isProgressing && this.progressIndicatorRef) {
+                this.progressService.close(this.progressIndicatorRef);
+                this.progressIndicatorRef = undefined;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorDirective, deps: [{ token: i0.ElementRef }, { token: i1.DfProgressIndicatorService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfProgressIndicatorDirective, isStandalone: true, selector: "[dfProgressIndicator]", inputs: { dfProgressIndicator: "dfProgressIndicator", dfProgressIndicatorConfig: "dfProgressIndicatorConfig" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dfProgressIndicator]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.DfProgressIndicatorService }]; }, propDecorators: { dfProgressIndicator: [{
+                type: Input
+            }], dfProgressIndicatorConfig: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/progressindicator/progressindicator.module.mjs

@@ -0,0 +1,45 @@
+import { NgModule } from '@angular/core';
+import { DfProgressbarModule } from '../progressbar/progressbar.module';
+import { DfProgressIndicatorContainerComponent } from './progressindicator-container.component';
+import { DfDefaultSpinnerComponent } from './default/default-spinner.component';
+import { DfProgressIndicatorBackdropComponent } from './progressindicator-backdrop.component';
+import { DfProgressIndicatorDirective } from './progressindicator.directive';
+import * as i0 from "@angular/core";
+export { DfProgressIndicatorContainerComponent } from './progressindicator-container.component';
+export { DfDefaultSpinnerComponent } from './default/default-spinner.component';
+export { DfProgressIndicatorBackdropComponent } from './progressindicator-backdrop.component';
+export { DfProgressIndicatorDirective } from './progressindicator.directive';
+export class DfProgressIndicatorModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorModule, imports: [DfDefaultSpinnerComponent,
+            DfProgressbarModule,
+            DfProgressIndicatorBackdropComponent,
+            DfProgressIndicatorContainerComponent,
+            DfProgressIndicatorDirective], exports: [DfProgressbarModule,
+            DfProgressIndicatorContainerComponent,
+            DfProgressIndicatorDirective,
+            DfProgressIndicatorBackdropComponent,
+            DfDefaultSpinnerComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorModule, imports: [DfDefaultSpinnerComponent,
+            DfProgressbarModule, DfProgressbarModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        DfDefaultSpinnerComponent,
+                        DfProgressbarModule,
+                        DfProgressIndicatorBackdropComponent,
+                        DfProgressIndicatorContainerComponent,
+                        DfProgressIndicatorDirective
+                    ],
+                    exports: [
+                        DfProgressbarModule,
+                        DfProgressIndicatorContainerComponent,
+                        DfProgressIndicatorDirective,
+                        DfProgressIndicatorBackdropComponent,
+                        DfDefaultSpinnerComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/progressindicator/progressindicator.service.mjs

@@ -0,0 +1,170 @@
+import { Injectable, Inject, ComponentRef, TemplateRef } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { DfProgressIndicatorContainerComponent } from './progressindicator-container.component';
+import { DfProgressIndicatorBackdropComponent } from './progressindicator-backdrop.component';
+import { DfProgressIndicatorContentSpinner, DfProgressIndicatorContentProgressBar } from './progressindicator-config';
+import { DfDefaultSpinnerComponent } from './default/default-spinner.component';
+import { DfProgressIndicatorRef } from './progressindicator-ref';
+import { DfProgressbarComponent } from '../progressbar/progressbar.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../utils/scrollbar.service";
+export class DfProgressIndicatorService {
+    constructor(document, rendererFactory, componentFactoryResolver, appRef, injector, scrollbar) {
+        this.document = document;
+        this.rendererFactory = rendererFactory;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.appRef = appRef;
+        this.injector = injector;
+        this.scrollbar = scrollbar;
+        this.BODY_CLASS = 'df-progressindicator-open';
+        // TODO - Remove it when https://github.com/angular/angular/issues/22567
+        this.containerAttributes = ['containerClass', 'position'];
+        this.backdropAttributes = ['backdropClass', 'isGlobalBackdrop'];
+        this.defaultSpinnerAttributes = ['contentClass', 'ariaLabel', 'isGlobalSpinner'];
+        this.defaultProgressBarAttributes = ['infiniteAnimation', 'ariaLabel'];
+        this.activeInstances = [];
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+    }
+    open(content, options) {
+        const containerElt = this.getContainer(this.document, options);
+        if (!containerElt) {
+            throw new Error(`[Design Factory] The specified progress indicator container "${options?.container ||
+                'body'}" was not found in the DOM.`);
+        }
+        // Create needed components
+        const backdropRef = options?.backdrop !== false
+            ? this.createComponent(DfProgressIndicatorBackdropComponent, this.componentFactoryResolver, undefined, containerElt)
+            : undefined;
+        const contentRef = this.getContent(content, this.componentFactoryResolver, containerElt);
+        const containerCmpRef = this.createComponent(DfProgressIndicatorContainerComponent, this.componentFactoryResolver, contentRef, containerElt);
+        const onDestroyOperations = [];
+        // Add aria attributes on the container
+        this.renderer.setAttribute(containerElt, 'aria-busy', 'true');
+        onDestroyOperations.push(() => {
+            this.renderer.removeAttribute(containerElt, 'aria-busy');
+        });
+        // Override some styles if body is the container
+        if (containerElt === this.document.body) {
+            const scrollCompensation = this.scrollbar.compensate();
+            this.renderer.addClass(this.document.body, this.BODY_CLASS);
+            this.renderer.setAttribute(this.document.body, 'aria-busy', 'true');
+            onDestroyOperations.push(() => {
+                scrollCompensation();
+                this.renderer.removeClass(this.document.body, this.BODY_CLASS);
+            });
+        }
+        if (onDestroyOperations.length > 0) {
+            containerCmpRef.onDestroy(() => {
+                onDestroyOperations.forEach(operation => {
+                    operation();
+                });
+            });
+        }
+        // Force override of position in case of the use of a progress bar component
+        if (content instanceof DfProgressIndicatorContentProgressBar) {
+            options = {
+                ...options,
+                position: content.position
+            };
+        }
+        // Apply options to the created components
+        if (backdropRef) {
+            this.applyOptions(backdropRef, this.backdropAttributes, { ...options, isGlobalBackdrop: containerElt === this.document.body });
+        }
+        this.applyOptions(containerCmpRef, this.containerAttributes, options);
+        const progressIndicatorRef = new DfProgressIndicatorRef(containerCmpRef, contentRef, backdropRef);
+        this.activeInstances.push(progressIndicatorRef);
+        return progressIndicatorRef;
+    }
+    close(progressIndicatorRef) {
+        const instanceIndex = this.activeInstances.indexOf(progressIndicatorRef);
+        if (instanceIndex > -1) {
+            Object.keys(progressIndicatorRef).forEach(key => {
+                const propertyValue = progressIndicatorRef[key];
+                if (propertyValue && propertyValue instanceof ComponentRef) {
+                    propertyValue.destroy();
+                    progressIndicatorRef[key] = undefined;
+                }
+            });
+            this.activeInstances.splice(instanceIndex, 1);
+        }
+        else {
+            throw new Error('[Design Factory] The specified progress indicator reference is no longer active and cannot be closed.');
+        }
+    }
+    /**
+     * Retrieve container according to the desired options.
+     */
+    getContainer(document, options) {
+        if (options?.container instanceof HTMLElement) {
+            return options.container;
+        }
+        return options?.container ? document.querySelector(options.container) : document.body;
+    }
+    getContent(content, cfr, container) {
+        if (!content) {
+            return this.createComponent(DfDefaultSpinnerComponent, cfr);
+        }
+        else if (content instanceof DfProgressIndicatorContentSpinner) {
+            const cmpRef = this.createComponent(DfDefaultSpinnerComponent, cfr);
+            this.applyOptions(cmpRef, this.defaultSpinnerAttributes, { ...content.spinnerInput, isGlobalSpinner: container === this.document.body });
+            return cmpRef;
+        }
+        else if (content instanceof DfProgressIndicatorContentProgressBar) {
+            const cmpRef = this.createComponent(DfProgressbarComponent, cfr);
+            this.applyOptions(cmpRef, this.defaultProgressBarAttributes, { ...content.progressBarInput, infiniteAnimation: true });
+            return cmpRef;
+        }
+        else if (content instanceof TemplateRef) {
+            const viewRef = content.createEmbeddedView({});
+            this.appRef.attachView(viewRef);
+            return viewRef;
+        }
+        else {
+            return this.createComponent(content, cfr);
+        }
+    }
+    createComponent(cmpType, cfr, childrenProjectables, container) {
+        const cmpFactory = cfr.resolveComponentFactory(cmpType);
+        let cmpRef;
+        if (childrenProjectables) {
+            if (childrenProjectables instanceof ComponentRef) {
+                cmpRef = cmpFactory.create(this.injector, [[childrenProjectables.location.nativeElement]]);
+            }
+            else {
+                cmpRef = cmpFactory.create(this.injector, [childrenProjectables.rootNodes]);
+            }
+        }
+        else {
+            cmpRef = cmpFactory.create(this.injector);
+        }
+        this.appRef.attachView(cmpRef.hostView);
+        if (container) {
+            container.appendChild(cmpRef.location.nativeElement);
+        }
+        return cmpRef;
+    }
+    applyOptions(cmpRef, availableOptions, options) {
+        if (options) {
+            const cmpInst = cmpRef.instance;
+            availableOptions.forEach((option) => {
+                const optionValue = options[option];
+                if (optionValue !== null && optionValue !== undefined) {
+                    cmpInst[option] = optionValue;
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorService, deps: [{ token: DOCUMENT }, { token: i0.RendererFactory2 }, { token: i0.ComponentFactoryResolver }, { token: i0.ApplicationRef }, { token: i0.Injector }, { token: i1.ScrollBar }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressIndicatorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.RendererFactory2 }, { type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i0.Injector }, { type: i1.ScrollBar }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progressindicator.service.js","sourceRoot":"","sources":["../../../../../../projects/design-factory/src/lib/angular/progressindicator/progressindicator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentFactoryResolver,\n  Injectable,\n  RendererFactory2,\n  Renderer2,\n  Inject,\n  ApplicationRef,\n  Injector,\n  EmbeddedViewRef,\n  ComponentRef,\n  Type,\n  TemplateRef\n} from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { DfProgressIndicatorContainerComponent } from './progressindicator-container.component';\nimport { DfProgressIndicatorBackdropComponent } from './progressindicator-backdrop.component';\nimport {\n  DfProgressIndicatorOptions,\n  DfProgressIndicatorContentSpinner,\n  DfProgressIndicatorContentProgressBar\n} from './progressindicator-config';\nimport { DfDefaultSpinnerComponent } from './default/default-spinner.component';\nimport { DfProgressIndicatorRef } from './progressindicator-ref';\nimport { DfProgressbarComponent } from '../progressbar/progressbar.component';\nimport { ScrollBar } from '../utils/scrollbar.service';\n\nexport type DfProgressIndicatorContent<T> =\n  | undefined\n  | TemplateRef<T>\n  | Type<T>\n  | DfProgressIndicatorContentSpinner\n  | DfProgressIndicatorContentProgressBar;\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DfProgressIndicatorService {\n  private readonly renderer: Renderer2;\n  private readonly BODY_CLASS = 'df-progressindicator-open';\n  // TODO - Remove it when https://github.com/angular/angular/issues/22567\n  private readonly containerAttributes = ['containerClass', 'position'];\n  private readonly backdropAttributes = ['backdropClass', 'isGlobalBackdrop'];\n  private readonly defaultSpinnerAttributes = ['contentClass', 'ariaLabel', 'isGlobalSpinner'];\n  private readonly defaultProgressBarAttributes = ['infiniteAnimation', 'ariaLabel'];\n\n  private readonly activeInstances: DfProgressIndicatorRef[] = [];\n\n  constructor(\n    @Inject(DOCUMENT) private readonly document: Document,\n    private readonly rendererFactory: RendererFactory2,\n    private readonly componentFactoryResolver: ComponentFactoryResolver,\n    private readonly appRef: ApplicationRef,\n    private readonly injector: Injector,\n    private readonly scrollbar: ScrollBar\n  ) {\n    this.renderer = this.rendererFactory.createRenderer(null, null);\n  }\n\n  open<T>(content: DfProgressIndicatorContent<T>, options?: DfProgressIndicatorOptions): DfProgressIndicatorRef {\n    const containerElt = this.getContainer(this.document, options);\n    if (!containerElt) {\n      throw new Error(\n        `[Design Factory] The specified progress indicator container \"${options?.container ||\n          'body'}\" was not found in the DOM.`\n      );\n    }\n\n    // Create needed components\n    const backdropRef: ComponentRef<DfProgressIndicatorBackdropComponent> | undefined =\n      options?.backdrop !== false\n        ? this.createComponent(\n            DfProgressIndicatorBackdropComponent,\n            this.componentFactoryResolver,\n            undefined,\n            containerElt\n          )\n        : undefined;\n\n    const contentRef = this.getContent(content, this.componentFactoryResolver, containerElt);\n    const containerCmpRef: ComponentRef<DfProgressIndicatorContainerComponent> = this.createComponent(\n      DfProgressIndicatorContainerComponent,\n      this.componentFactoryResolver,\n      contentRef,\n      containerElt\n    );\n\n    const onDestroyOperations: (() => void)[] = [];\n\n    // Add aria attributes on the container\n    this.renderer.setAttribute(containerElt, 'aria-busy', 'true');\n    onDestroyOperations.push(() => {\n      this.renderer.removeAttribute(containerElt, 'aria-busy');\n    });\n\n    // Override some styles if body is the container\n    if (containerElt === this.document.body) {\n      const scrollCompensation = this.scrollbar.compensate();\n      this.renderer.addClass(this.document.body, this.BODY_CLASS);\n      this.renderer.setAttribute(this.document.body, 'aria-busy', 'true');\n\n      onDestroyOperations.push(() => {\n        scrollCompensation();\n        this.renderer.removeClass(this.document.body, this.BODY_CLASS);\n      });\n    }\n\n    if (onDestroyOperations.length > 0) {\n      containerCmpRef.onDestroy(() => {\n        onDestroyOperations.forEach(operation => {\n          operation();\n        });\n      });\n    }\n\n    // Force override of position in case of the use of a progress bar component\n    if (content instanceof DfProgressIndicatorContentProgressBar) {\n      options = {\n        ...options,\n        position: content.position\n      };\n    }\n\n    // Apply options to the created components\n    if (backdropRef) {\n      this.applyOptions(\n        backdropRef,\n        this.backdropAttributes,\n        { ...options, isGlobalBackdrop: containerElt === this.document.body }\n      );\n    }\n    this.applyOptions(containerCmpRef, this.containerAttributes, options);\n\n    const progressIndicatorRef = new DfProgressIndicatorRef(containerCmpRef, contentRef, backdropRef);\n    this.activeInstances.push(progressIndicatorRef);\n    return progressIndicatorRef;\n  }\n\n  close(progressIndicatorRef: DfProgressIndicatorRef): void {\n    const instanceIndex = this.activeInstances.indexOf(progressIndicatorRef);\n    if (instanceIndex > -1) {\n      Object.keys(progressIndicatorRef).forEach(key => {\n        const propertyValue = (progressIndicatorRef as unknown as { [key: string]: unknown })[key];\n        if (propertyValue && propertyValue instanceof ComponentRef) {\n          propertyValue.destroy();\n          (progressIndicatorRef as unknown as { [key: string]: unknown })[key] = undefined;\n        }\n      });\n      this.activeInstances.splice(instanceIndex, 1);\n    } else {\n      throw new Error(\n        '[Design Factory] The specified progress indicator reference is no longer active and cannot be closed.'\n      );\n    }\n  }\n\n  /**\n   * Retrieve container according to the desired options.\n   */\n  private getContainer(document: Document, options?: DfProgressIndicatorOptions): HTMLElement | null {\n    if (options?.container instanceof HTMLElement) {\n      return options.container;\n    }\n    return options?.container ? document.querySelector(options.container) : document.body;\n  }\n\n  private getContent<T>(\n    content: DfProgressIndicatorContent<T>,\n    cfr: ComponentFactoryResolver,\n    container: HTMLElement\n  ): ComponentRef<any> | EmbeddedViewRef<any> {\n    if (!content) {\n      return this.createComponent(DfDefaultSpinnerComponent, cfr);\n    } else if (content instanceof DfProgressIndicatorContentSpinner) {\n      const cmpRef = this.createComponent(DfDefaultSpinnerComponent, cfr);\n      this.applyOptions(\n        cmpRef,\n        this.defaultSpinnerAttributes,\n        { ...content.spinnerInput, isGlobalSpinner: container === this.document.body }\n      );\n      return cmpRef;\n    } else if (content instanceof DfProgressIndicatorContentProgressBar) {\n      const cmpRef = this.createComponent(DfProgressbarComponent, cfr);\n      this.applyOptions(\n        cmpRef,\n        this.defaultProgressBarAttributes,\n        { ...content.progressBarInput, infiniteAnimation: true }\n      );\n      return cmpRef;\n    } else if (content instanceof TemplateRef) {\n      const viewRef = content.createEmbeddedView({} as T);\n      this.appRef.attachView(viewRef);\n      return viewRef;\n    } else {\n      return this.createComponent(content, cfr);\n    }\n  }\n\n  private createComponent<T>(\n    cmpType: Type<T>,\n    cfr: ComponentFactoryResolver,\n    childrenProjectables?: ComponentRef<unknown> | EmbeddedViewRef<unknown>,\n    container?: HTMLElement\n  ): ComponentRef<T> {\n    const cmpFactory = cfr.resolveComponentFactory(cmpType);\n    let cmpRef: ComponentRef<T>;\n    if (childrenProjectables) {\n      if (childrenProjectables instanceof ComponentRef) {\n        cmpRef = cmpFactory.create(this.injector, [[childrenProjectables.location.nativeElement]]);\n      } else {\n        cmpRef = cmpFactory.create(this.injector, [childrenProjectables.rootNodes]);\n      }\n    } else {\n      cmpRef = cmpFactory.create(this.injector);\n    }\n    this.appRef.attachView(cmpRef.hostView);\n    if (container) {\n      container.appendChild(cmpRef.location.nativeElement);\n    }\n    return cmpRef;\n  }\n\n  private applyOptions<T>(\n    cmpRef: ComponentRef<T>,\n    availableOptions: string[],\n    options?: DfProgressIndicatorOptions | { [key: string]: unknown }\n  ): void {\n    if (options) {\n      const cmpInst = cmpRef.instance;\n      availableOptions.forEach((option: string) => {\n        const optionValue = (options as { [key: string]: unknown })[option];\n        if (optionValue !== null && optionValue !== undefined) {\n          (cmpInst as unknown as { [key: string]: unknown })[option] = optionValue;\n        }\n      });\n    }\n  }\n}\n"]}

package/esm2022/lib/angular/right-to-left/directionDetection.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export var RightToLeftDirectionEnum;
+(function (RightToLeftDirectionEnum) {
+    RightToLeftDirectionEnum["LeftToRight"] = "ltr";
+    RightToLeftDirectionEnum["RightToLeft"] = "rtl";
+    RightToLeftDirectionEnum["Auto"] = "auto";
+})(RightToLeftDirectionEnum || (RightToLeftDirectionEnum = {}));
+export class DfDirectionDetectionService {
+    getPageDirection(element) {
+        let curElement = element.nativeElement;
+        while (curElement !== null) {
+            if (curElement.getAttribute('dir') === RightToLeftDirectionEnum.RightToLeft) {
+                return RightToLeftDirectionEnum.RightToLeft;
+            }
+            else if (curElement.getAttribute('dir') === RightToLeftDirectionEnum.LeftToRight) {
+                return RightToLeftDirectionEnum.LeftToRight;
+            }
+            curElement = curElement.parentElement;
+        }
+        return RightToLeftDirectionEnum.LeftToRight;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfDirectionDetectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfDirectionDetectionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfDirectionDetectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/selects/events/manage-badge-events.directive.mjs

@@ -0,0 +1,65 @@
+import { DF_SELECT_CLASS } from '../select.model';
+import { Directive, HostListener, Input, HostBinding } from '@angular/core';
+import * as i0 from "@angular/core";
+// Put to avoid opening of the select after removal. See why in file:
+// https://github.com/ng-select/ng-select/blob/57c6671a972d23beddcca2b6acc9418544c17a2e/src/ng-select/ng-select.component.ts#L307
+const NG_SELECT_CLASS_IDENTIFIER = 'ng-value-icon';
+export class DfManageBadgeEventsDirective {
+    constructor(renderer, element) {
+        this.renderer = renderer;
+        this.element = element;
+        this.tabindex = '-1';
+        this.renderer.addClass(this.element.nativeElement, DF_SELECT_CLASS);
+        this.renderer.addClass(this.element.nativeElement, NG_SELECT_CLASS_IDENTIFIER);
+    }
+    ngAfterViewInit() {
+        const childs = this.element.nativeElement.children;
+        const map = Array.from(childs);
+        map.forEach((element) => {
+            this.renderer.addClass(element, NG_SELECT_CLASS_IDENTIFIER);
+        });
+    }
+    handleKeyDownBackspace(event) {
+        this.dfManageBadgeEventsSelect[0](this.dfManageBadgeEventsSelect[1]);
+        event.stopPropagation();
+    }
+    handleClick(event) {
+        this.dfManageBadgeEventsSelect[0](this.dfManageBadgeEventsSelect[1]);
+        event.stopPropagation();
+    }
+    handleKeyDownEnter(event) {
+        this.dfManageBadgeEventsSelect[0](this.dfManageBadgeEventsSelect[1]);
+        event.stopPropagation();
+    }
+    handleKeyDownDelete(event) {
+        this.dfManageBadgeEventsSelect[0](this.dfManageBadgeEventsSelect[1]);
+        event.stopPropagation();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfManageBadgeEventsDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfManageBadgeEventsDirective, isStandalone: true, selector: "[dfManageBadgeEventsSelect]", inputs: { dfManageBadgeEventsSelect: "dfManageBadgeEventsSelect" }, host: { listeners: { "keydown.Backspace": "handleKeyDownBackspace($event)", "click": "handleClick($event)", "keydown.Enter": "handleKeyDownEnter($event)", "keydown.Delete": "handleKeyDownDelete($event)" }, properties: { "attr.tabindex": "this.tabindex" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfManageBadgeEventsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dfManageBadgeEventsSelect]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { dfManageBadgeEventsSelect: [{
+                type: Input
+            }], tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], handleKeyDownBackspace: [{
+                type: HostListener,
+                args: ['keydown.Backspace', ['$event']]
+            }], handleClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], handleKeyDownEnter: [{
+                type: HostListener,
+                args: ['keydown.Enter', ['$event']]
+            }], handleKeyDownDelete: [{
+                type: HostListener,
+                args: ['keydown.Delete', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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