@design-factory/design-factory 15.2.0

package/esm2022/lib/angular/selects/nav/manage-nav-select.directive.mjs

@@ -0,0 +1,108 @@
+import { Directive, Host, HostListener } from '@angular/core';
+import { RightToLeftDirectionEnum } from '../../right-to-left/directionDetection.service';
+import { DF_SELECT_CLASS } from '../select.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-select/ng-select";
+import * as i2 from "../../right-to-left/directionDetection.service";
+export class DfManageNavSelectDirective {
+    constructor(select, element, rtlDirectionService, renderer) {
+        this.select = select;
+        this.element = element;
+        this.rtlDirectionService = rtlDirectionService;
+        this.renderer = renderer;
+    }
+    ngOnInit() {
+        this.direction = this.rtlDirectionService.getPageDirection(this.element);
+    }
+    handleKeyDown(event) {
+        if (this.direction === RightToLeftDirectionEnum.LeftToRight) {
+            this.arrowLeftInnerHandler(event);
+        }
+        else {
+            this.arrowRightInnerHandler(event);
+        }
+    }
+    handleKeyDownBackspace(event) {
+        // Clear on backspace is already handled by ng select when clearable is true
+        if (!this.select.clearable && !this.select.searchTerm) {
+            const listBadge = this.element.nativeElement.querySelectorAll(`.${DF_SELECT_CLASS}`);
+            if (listBadge.length > 0) {
+                listBadge[listBadge.length - 1].click();
+            }
+        }
+    }
+    handleKeyDownRight(event) {
+        if (this.direction === RightToLeftDirectionEnum.LeftToRight) {
+            this.arrowRightInnerHandler(event);
+        }
+        else {
+            this.arrowLeftInnerHandler(event);
+        }
+    }
+    arrowRightInnerHandler(event) {
+        const listBadge = this.element.nativeElement.querySelectorAll(`.${DF_SELECT_CLASS}`);
+        const currentPos = Array.prototype.indexOf.call(listBadge, document.activeElement);
+        // Test if the focus is in the list (otherwise it is in the input and we do nothing)
+        if (currentPos !== -1) {
+            if (currentPos === listBadge.length - 1) {
+                this.select.focus();
+            }
+            else {
+                (listBadge[currentPos + 1] || document.activeElement).focus();
+            }
+        }
+        else if (event.target.selectionStart === event.target.selectionEnd &&
+            event.target.nodeName === 'INPUT' &&
+            event.target.selectionStart === event.target.value.length) {
+            const clearEl = this.element.nativeElement.querySelector('.ng-clear-wrapper') ||
+                this.element.nativeElement.querySelector('.ng-clear');
+            if (clearEl) {
+                // Event if it can be added multiple time it is not an issue I think.
+                this.renderer.listen(clearEl, 'keydown.Enter', (e) => {
+                    e.stopPropagation(); // kill the event to forbid default ng-select behavior (open the dropdown)
+                    this.select.handleClearClick();
+                });
+                clearEl.setAttribute('tabindex', '1'); // To be able to focus the element in chrome
+                clearEl.focus();
+            }
+        }
+    }
+    arrowLeftInnerHandler(event) {
+        const listBadge = this.element.nativeElement.querySelectorAll(`.${DF_SELECT_CLASS}`);
+        if (event.target.selectionStart === event.target.selectionEnd &&
+            event.target.selectionStart === 0 &&
+            event.target.nodeName === 'INPUT') {
+            if (listBadge.length > 0) {
+                listBadge[listBadge.length - 1].focus();
+            }
+        }
+        else if (event.target.classList.contains('ng-clear-wrapper') || event.target.classList.contains('ng-clear')) {
+            this.select.focus();
+        }
+        else {
+            const currentPos = Array.prototype.indexOf.call(listBadge, document.activeElement);
+            (listBadge[currentPos - 1] || document.activeElement).focus();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfManageNavSelectDirective, deps: [{ token: i1.NgSelectComponent, host: true }, { token: i0.ElementRef }, { token: i2.DfDirectionDetectionService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfManageNavSelectDirective, isStandalone: true, selector: "[dfManageNavSelect]", host: { listeners: { "keydown.arrowLeft": "handleKeyDown($event)", "keydown.Backspace": "handleKeyDownBackspace($event)", "keydown.arrowRight": "handleKeyDownRight($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfManageNavSelectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dfManageNavSelect]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgSelectComponent, decorators: [{
+                    type: Host
+                }] }, { type: i0.ElementRef }, { type: i2.DfDirectionDetectionService }, { type: i0.Renderer2 }]; }, propDecorators: { handleKeyDown: [{
+                type: HostListener,
+                args: ['keydown.arrowLeft', ['$event']]
+            }], handleKeyDownBackspace: [{
+                type: HostListener,
+                args: ['keydown.Backspace', ['$event']]
+            }], handleKeyDownRight: [{
+                type: HostListener,
+                args: ['keydown.arrowRight', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manage-nav-select.directive.js","sourceRoot":"","sources":["../../../../../../../projects/design-factory/src/lib/angular/selects/nav/manage-nav-select.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Host, ElementRef, HostListener, OnInit, Renderer2 } from '@angular/core';\nimport { NgSelectComponent } from '@ng-select/ng-select';\nimport { DfDirectionDetectionService, RightToLeftDirectionEnum } from '../../right-to-left/directionDetection.service';\nimport { DF_SELECT_CLASS } from '../select.model';\n\n@Directive({\n  selector: '[dfManageNavSelect]',\n  standalone: true\n})\nexport class DfManageNavSelectDirective implements OnInit {\n  private direction!: string;\n\n  constructor(\n    @Host() private readonly select: NgSelectComponent,\n    private readonly element: ElementRef,\n    private readonly rtlDirectionService: DfDirectionDetectionService,\n    private readonly renderer: Renderer2\n  ) {}\n\n  ngOnInit(): void {\n    this.direction = this.rtlDirectionService.getPageDirection(this.element);\n  }\n\n  @HostListener('keydown.arrowLeft', ['$event'])\n  handleKeyDown(event: any) {\n    if (this.direction === RightToLeftDirectionEnum.LeftToRight) {\n      this.arrowLeftInnerHandler(event);\n    } else {\n      this.arrowRightInnerHandler(event);\n    }\n  }\n\n  @HostListener('keydown.Backspace', ['$event']) handleKeyDownBackspace(event: any) {\n    // Clear on backspace is already handled by ng select when clearable is true\n    if (!this.select.clearable && !this.select.searchTerm) {\n      const listBadge = this.element.nativeElement.querySelectorAll(`.${DF_SELECT_CLASS}`);\n      if (listBadge.length > 0) {\n        listBadge[listBadge.length - 1].click();\n      }\n    }\n  }\n\n  @HostListener('keydown.arrowRight', ['$event'])\n  handleKeyDownRight(event: any) {\n    if (this.direction === RightToLeftDirectionEnum.LeftToRight) {\n      this.arrowRightInnerHandler(event);\n    } else {\n      this.arrowLeftInnerHandler(event);\n    }\n  }\n\n  arrowRightInnerHandler(event: any) {\n    const listBadge = this.element.nativeElement.querySelectorAll(`.${DF_SELECT_CLASS}`);\n    const currentPos = Array.prototype.indexOf.call(listBadge, document.activeElement);\n    // Test if the focus is in the list (otherwise it is in the input and we do nothing)\n    if (currentPos !== -1) {\n      if (currentPos === listBadge.length - 1) {\n        this.select.focus();\n      } else {\n        (listBadge[currentPos + 1] || document.activeElement).focus();\n      }\n    } else if (\n      event.target.selectionStart === event.target.selectionEnd &&\n      event.target.nodeName === 'INPUT' &&\n      event.target.selectionStart === event.target.value.length\n    ) {\n      const clearEl =\n        this.element.nativeElement.querySelector('.ng-clear-wrapper') ||\n        this.element.nativeElement.querySelector('.ng-clear');\n      if (clearEl) {\n        // Event if it can be added multiple time it is not an issue I think.\n        this.renderer.listen(clearEl, 'keydown.Enter', (e) => {\n          e.stopPropagation(); // kill the event to forbid default ng-select behavior (open the dropdown)\n          this.select.handleClearClick();\n        });\n        clearEl.setAttribute('tabindex', '1'); // To be able to focus the element in chrome\n        clearEl.focus();\n      }\n    }\n  }\n\n  arrowLeftInnerHandler(event: any) {\n    const listBadge = this.element.nativeElement.querySelectorAll(`.${DF_SELECT_CLASS}`);\n    if (\n      event.target.selectionStart === event.target.selectionEnd &&\n      event.target.selectionStart === 0 &&\n      event.target.nodeName === 'INPUT'\n    ) {\n      if (listBadge.length > 0) {\n        listBadge[listBadge.length - 1].focus();\n      }\n    } else if (event.target.classList.contains('ng-clear-wrapper') || event.target.classList.contains('ng-clear')) {\n      this.select.focus();\n    } else {\n      const currentPos = Array.prototype.indexOf.call(listBadge, document.activeElement);\n      (listBadge[currentPos - 1] || document.activeElement).focus();\n    }\n  }\n}\n"]}

package/esm2022/lib/angular/selects/option-highlight.directive.mjs

@@ -0,0 +1,59 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+// Copy of https://github.com/ng-select/ng-select/blob/master/src/ng-option-highlight/lib/ng-option-highlight.directive.ts
+export class DfOptionHighlightDirective {
+    constructor(elementRef, renderer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.element = this.elementRef.nativeElement;
+    }
+    ngOnChanges() {
+        if (this.canHighlight) {
+            this.highlightLabel();
+        }
+        else if (this.label) { // unhighlight if there was some
+            this.setInnerHtml(this.label);
+        }
+    }
+    ngAfterViewInit() {
+        this.label = this.element.innerHTML;
+        if (this.canHighlight) {
+            this.highlightLabel();
+        }
+    }
+    escapeRegExp(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    highlightLabel() {
+        const label = this.label;
+        if (!this.term) {
+            this.setInnerHtml(label);
+            return;
+        }
+        const alternationString = this.escapeRegExp(this.term).replace(' ', '|');
+        const termRegex = new RegExp(alternationString, 'gi');
+        this.setInnerHtml(label.replace(termRegex, `<span class=\"highlighted\">$&</span>`));
+    }
+    get canHighlight() {
+        return this.isDefined(this.term) && this.isDefined(this.label);
+    }
+    setInnerHtml(html) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'innerHTML', html);
+    }
+    isDefined(value) {
+        return value !== undefined && value !== null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfOptionHighlightDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfOptionHighlightDirective, isStandalone: true, selector: "[dfOptionHighlight]", inputs: { term: ["dfOptionHighlight", "term"] }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfOptionHighlightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dfOptionHighlight]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { term: [{
+                type: Input,
+                args: ['dfOptionHighlight']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/selects/select.model.mjs

@@ -0,0 +1,2 @@
+export const DF_SELECT_CLASS = 'df-ym';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGVzaWduLWZhY3Rvcnkvc3JjL2xpYi9hbmd1bGFyL3NlbGVjdHMvc2VsZWN0Lm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgREZfU0VMRUNUX0NMQVNTID0gJ2RmLXltJztcbiJdfQ==

package/esm2022/lib/angular/selects/select.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { DfManageNavSelectDirective } from './nav/manage-nav-select.directive';
+import { DfManageBadgeEventsDirective } from './events/manage-badge-events.directive';
+import { NgSelectModule } from '@ng-select/ng-select';
+import { DfOptionHighlightDirective } from './option-highlight.directive';
+import * as i0 from "@angular/core";
+export { DfManageNavSelectDirective } from './nav/manage-nav-select.directive';
+export { DfManageBadgeEventsDirective } from './events/manage-badge-events.directive';
+export { DfOptionHighlightDirective } from './option-highlight.directive';
+export class DfSelectModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: DfSelectModule, imports: [DfManageNavSelectDirective, DfManageBadgeEventsDirective, DfOptionHighlightDirective], exports: [DfManageNavSelectDirective, DfManageBadgeEventsDirective, DfOptionHighlightDirective, NgSelectModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSelectModule, imports: [NgSelectModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSelectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [DfManageNavSelectDirective, DfManageBadgeEventsDirective, DfOptionHighlightDirective],
+                    exports: [DfManageNavSelectDirective, DfManageBadgeEventsDirective, DfOptionHighlightDirective, NgSelectModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/sidenav/dfSideNavAnimation.mjs

@@ -0,0 +1,73 @@
+import { reflow } from '../animation/util';
+function measureCollapsingElementWidthPx(element) {
+    // SSR fix for without injecting the PlatformId
+    if (typeof navigator === 'undefined') {
+        return '0px';
+    }
+    const { classList } = element;
+    const hasShownClass = classList.contains('df-show');
+    if (!hasShownClass) {
+        classList.add('df-show');
+    }
+    element.style.width = '';
+    const width = `${element.getBoundingClientRect().width}px`;
+    if (!hasShownClass) {
+        classList.remove('df-show');
+    }
+    return width;
+}
+export const DfCollapsingTransition = (element, animation, context) => {
+    const { direction, minimized } = context;
+    let { maxWidth } = context;
+    const { classList } = element;
+    const dfcollapsingClass = 'df-collapsing';
+    const dfminimizingClass = 'df-minimizing';
+    function setInitialClasses() {
+        if (minimized) {
+            classList.add('df-minimized');
+        }
+        else {
+            classList.add('df-collapse');
+        }
+        if (direction === 'show') {
+            classList.add('df-show');
+        }
+        else {
+            classList.remove('df-show');
+        }
+    }
+    // without animations we just need to set initial classes
+    if (!animation) {
+        setInitialClasses();
+        return () => { };
+    }
+    // No maxWidth -> running the transition for the first time
+    if (!maxWidth) {
+        maxWidth = measureCollapsingElementWidthPx(element);
+        context.maxWidth = maxWidth;
+        // Fix the width before starting the animation
+        element.style.width = direction !== 'show' ? maxWidth : minimized ? '50px' : '0px';
+        classList.remove('df-collapse');
+        classList.remove('df-minimized'); // add
+        classList.remove(dfcollapsingClass);
+        classList.remove(dfminimizingClass);
+        classList.remove('df-show');
+        reflow(element);
+        // Start the animation
+        if (minimized) {
+            classList.add(dfminimizingClass);
+        }
+        else {
+            classList.add(dfcollapsingClass);
+        }
+    }
+    // Start or revert the animation
+    element.style.width = direction === 'show' ? maxWidth : minimized ? '50px' : '0px';
+    return () => {
+        setInitialClasses();
+        classList.remove(dfcollapsingClass);
+        classList.remove(dfminimizingClass);
+        element.style.width = '';
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/sidenav/dfSideNavCollapse.mjs

@@ -0,0 +1,94 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { ngbRunTransition } from '../animation/ngbTransition';
+import { Subscription } from 'rxjs';
+import { DfCollapsingTransition } from './dfSideNavAnimation';
+import * as i0 from "@angular/core";
+import * as i1 from "./dfSideNavCollapse.service";
+/**
+ * A directive to provide a simple way of hiding and showing the sideNav on the page.
+ */
+export class DfSideNavCollapseDirective {
+    constructor(_element, _sideNavCollapseService, _zone) {
+        this._element = _element;
+        this._sideNavCollapseService = _sideNavCollapseService;
+        this._zone = _zone;
+        this.dfSideNavCollapseChange = new EventEmitter();
+        /**
+         * An event emitted when the collapse element is shown, after the transition. It has no payload.
+         *
+         * @since 9.1.0
+         */
+        this.shown = new EventEmitter();
+        /**
+         * An event emitted when the collapse element is hidden, after the transition. It has no payload.
+         *
+         * @since 9.1.0
+         */
+        this.hidden = new EventEmitter();
+        this.minimized = false;
+        this.animation = false;
+        this.subscription = new Subscription();
+        this.subscription.add(_sideNavCollapseService.sideNavAnimation$.subscribe((value) => {
+            this.animation = value;
+        }));
+    }
+    ngOnInit() {
+        this._runTransition(this.collapsed, false, this.minimized);
+    }
+    ngOnChanges(simpleChanges) {
+        if (simpleChanges['collapsed'] && !simpleChanges['collapsed'].firstChange) {
+            this._runTransitionWithEvents(this.collapsed, this.animation, this.minimized);
+        }
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    /**
+     * Triggers collapsing programmatically.
+     *
+     * If there is a collapsing transition running already, it will be reversed.
+     * If the animations are turned off this happens synchronously.
+     *
+     * @since 9.1.0
+     */
+    toggle(open = this.collapsed) {
+        this.collapsed = !open;
+        this.dfSideNavCollapseChange.next(this.collapsed);
+        this._runTransitionWithEvents(this.collapsed, this.animation, this.minimized);
+    }
+    _runTransition(collapsed, animation, minimizedInput) {
+        return ngbRunTransition(this._zone, this._element.nativeElement, DfCollapsingTransition, {
+            animation,
+            runningTransition: 'stop',
+            context: { direction: collapsed ? 'hide' : 'show', minimized: minimizedInput }
+        });
+    }
+    _runTransitionWithEvents(collapsed, animation, minimized) {
+        this._runTransition(collapsed, animation, minimized).subscribe(() => {
+            if (collapsed) {
+                this.hidden.emit();
+            }
+            else {
+                this.shown.emit();
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseDirective, deps: [{ token: i0.ElementRef }, { token: i1.DfSideNavCollapseService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfSideNavCollapseDirective, isStandalone: true, selector: "[dfSideNavCollapse]", inputs: { collapsed: ["dfSideNavCollapse", "collapsed"], minimized: "minimized" }, outputs: { dfSideNavCollapseChange: "dfSideNavCollapseChange", shown: "shown", hidden: "hidden" }, exportAs: ["dfSideNavCollapse"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[dfSideNavCollapse]', exportAs: 'dfSideNavCollapse', standalone: true }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.DfSideNavCollapseService }, { type: i0.NgZone }]; }, propDecorators: { collapsed: [{
+                type: Input,
+                args: ['dfSideNavCollapse']
+            }], dfSideNavCollapseChange: [{
+                type: Output
+            }], shown: [{
+                type: Output
+            }], hidden: [{
+                type: Output
+            }], minimized: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/sidenav/dfSideNavCollapse.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { DfSideNavCollapseDirective } from './dfSideNavCollapse';
+import * as i0 from "@angular/core";
+export { DfSideNavCollapseDirective } from './dfSideNavCollapse';
+export { DfSideNavCollapseConfig } from './dfSideNavCollapseConfig';
+export class DfSideNavCollapseModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseModule, imports: [DfSideNavCollapseDirective], exports: [DfSideNavCollapseDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [DfSideNavCollapseDirective],
+                    exports: [DfSideNavCollapseDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGZTaWRlTmF2Q29sbGFwc2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGVzaWduLWZhY3Rvcnkvc3JjL2xpYi9hbmd1bGFyL3NpZGVuYXYvZGZTaWRlTmF2Q29sbGFwc2UubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0scUJBQXFCLENBQUM7O0FBRWpFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBTXBFLE1BQU0sT0FBTyx1QkFBdUI7OEdBQXZCLHVCQUF1QjsrR0FBdkIsdUJBQXVCLFlBSHhCLDBCQUEwQixhQUMxQiwwQkFBMEI7K0dBRXpCLHVCQUF1Qjs7MkZBQXZCLHVCQUF1QjtrQkFKbkMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQywwQkFBMEIsQ0FBQztvQkFDckMsT0FBTyxFQUFFLENBQUMsMEJBQTBCLENBQUM7aUJBQ3RDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERmU2lkZU5hdkNvbGxhcHNlRGlyZWN0aXZlIH0gZnJvbSAnLi9kZlNpZGVOYXZDb2xsYXBzZSc7XG5cbmV4cG9ydCB7IERmU2lkZU5hdkNvbGxhcHNlRGlyZWN0aXZlIH0gZnJvbSAnLi9kZlNpZGVOYXZDb2xsYXBzZSc7XG5leHBvcnQgeyBEZlNpZGVOYXZDb2xsYXBzZUNvbmZpZyB9IGZyb20gJy4vZGZTaWRlTmF2Q29sbGFwc2VDb25maWcnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbRGZTaWRlTmF2Q29sbGFwc2VEaXJlY3RpdmVdLFxuICBleHBvcnRzOiBbRGZTaWRlTmF2Q29sbGFwc2VEaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIERmU2lkZU5hdkNvbGxhcHNlTW9kdWxlIHt9XG4iXX0=

package/esm2022/lib/angular/sidenav/dfSideNavCollapse.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./dfSideNavCollapseConfig";
+/**
+ * A service for managing the sidenav panel animation.
+ * This service is included at root level
+ *
+ * Creating a sidenav is straightforward: use [DfSideNavComponent](#/components/sidenav/api#DfSideNavComponent) component
+ */
+export class DfSideNavCollapseService {
+    constructor(_config) {
+        this._config = _config;
+        this._sideNavAnimation$ = new BehaviorSubject(_config.animation);
+    }
+    get sideNavAnimation$() {
+        return this._sideNavAnimation$.asObservable();
+    }
+    /**
+     * Use this to activate or desactivate the animation for the sideNav
+     * If input is `True` it will activate the animation.
+     * Default value for animation is set in by DfSideNavCollapseConfig
+     *
+     */
+    setAnimation(on) {
+        this._sideNavAnimation$.next(on);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseService, deps: [{ token: i1.DfSideNavCollapseConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DfSideNavCollapseConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/sidenav/dfSideNavCollapseConfig.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-bootstrap/ng-bootstrap";
+/**
+ * A configuration service for the [DfSideNavCollapseDirective](#/components/sidenav/api#DfSideNavCollapseDirective) component.
+ *
+ * You can inject this service, typically in your root component, and customize its properties
+ * to provide default values for the sideNav used in the application.
+ */
+export class DfSideNavCollapseConfig {
+    constructor(_ngbConfig) {
+        this._ngbConfig = _ngbConfig;
+    }
+    get animation() {
+        return this._animation === undefined ? this._ngbConfig.animation : this._animation;
+    }
+    set animation(animation) {
+        this._animation = animation;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseConfig, deps: [{ token: i1.NgbConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseConfig, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavCollapseConfig, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.NgbConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGZTaWRlTmF2Q29sbGFwc2VDb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tZmFjdG9yeS9zcmMvbGliL2FuZ3VsYXIvc2lkZW5hdi9kZlNpZGVOYXZDb2xsYXBzZUNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFHM0M7Ozs7O0dBS0c7QUFFSCxNQUFNLE9BQU8sdUJBQXVCO0lBR2xDLFlBQTZCLFVBQXFCO1FBQXJCLGVBQVUsR0FBVixVQUFVLENBQVc7SUFBRyxDQUFDO0lBRXRELElBQUksU0FBUztRQUNYLE9BQU8sSUFBSSxDQUFDLFVBQVUsS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDO0lBQ3JGLENBQUM7SUFDRCxJQUFJLFNBQVMsQ0FBQyxTQUFrQjtRQUM5QixJQUFJLENBQUMsVUFBVSxHQUFHLFNBQVMsQ0FBQztJQUM5QixDQUFDOzhHQVZVLHVCQUF1QjtrSEFBdkIsdUJBQXVCLGNBRFYsTUFBTTs7MkZBQ25CLHVCQUF1QjtrQkFEbkMsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBOZ2JDb25maWcgfSBmcm9tICdAbmctYm9vdHN0cmFwL25nLWJvb3RzdHJhcCc7XG5cbi8qKlxuICogQSBjb25maWd1cmF0aW9uIHNlcnZpY2UgZm9yIHRoZSBbRGZTaWRlTmF2Q29sbGFwc2VEaXJlY3RpdmVdKCMvY29tcG9uZW50cy9zaWRlbmF2L2FwaSNEZlNpZGVOYXZDb2xsYXBzZURpcmVjdGl2ZSkgY29tcG9uZW50LlxuICpcbiAqIFlvdSBjYW4gaW5qZWN0IHRoaXMgc2VydmljZSwgdHlwaWNhbGx5IGluIHlvdXIgcm9vdCBjb21wb25lbnQsIGFuZCBjdXN0b21pemUgaXRzIHByb3BlcnRpZXNcbiAqIHRvIHByb3ZpZGUgZGVmYXVsdCB2YWx1ZXMgZm9yIHRoZSBzaWRlTmF2IHVzZWQgaW4gdGhlIGFwcGxpY2F0aW9uLlxuICovXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIERmU2lkZU5hdkNvbGxhcHNlQ29uZmlnIHtcbiAgcHJpdmF0ZSBfYW5pbWF0aW9uPzogYm9vbGVhbjtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IF9uZ2JDb25maWc6IE5nYkNvbmZpZykge31cblxuICBnZXQgYW5pbWF0aW9uKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLl9hbmltYXRpb24gPT09IHVuZGVmaW5lZCA/IHRoaXMuX25nYkNvbmZpZy5hbmltYXRpb24gOiB0aGlzLl9hbmltYXRpb247XG4gIH1cbiAgc2V0IGFuaW1hdGlvbihhbmltYXRpb246IGJvb2xlYW4pIHtcbiAgICB0aGlzLl9hbmltYXRpb24gPSBhbmltYXRpb247XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/angular/sidenav/excludeTrap.directive.mjs

@@ -0,0 +1,55 @@
+import { Directive, Input } from '@angular/core';
+import { fromEvent, Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * The directive to catch focusin event and put the focus at a defined position in the page
+ *
+ * @since 9.1.0
+ */
+export class DfExcludeTrapDirective {
+    constructor(zone, element) {
+        this.zone = zone;
+        this.element = element;
+        this.subscription = new Subscription();
+    }
+    init() {
+        this.subscription = fromEvent(this.element.nativeElement, 'focusin').subscribe(() => {
+            const el = document.querySelector(this.dfExcludeTrapSelector);
+            if (el) {
+                el.focus();
+            }
+        });
+    }
+    ngOnInit() {
+        this.zone.runOutsideAngular(() => {
+            this.subscriptionInput = this.dfExcludeTrap.subscribe(isPresent => {
+                if (isPresent) {
+                    this.init();
+                }
+                else {
+                    this.subscription.unsubscribe();
+                }
+            });
+        });
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+        if (this.subscriptionInput) {
+            this.subscriptionInput.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfExcludeTrapDirective, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfExcludeTrapDirective, isStandalone: true, selector: "[dfExcludeTrap]", inputs: { dfExcludeTrapSelector: "dfExcludeTrapSelector", dfExcludeTrap: "dfExcludeTrap" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfExcludeTrapDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dfExcludeTrap]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }]; }, propDecorators: { dfExcludeTrapSelector: [{
+                type: Input
+            }], dfExcludeTrap: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/sidenav/manage-sidenav.directive.mjs

@@ -0,0 +1,26 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DfManageSideNavDirective {
+    constructor(element, renderer) {
+        this.element = element;
+        this.renderer = renderer;
+    }
+    ngAfterViewChecked() {
+        if (this.element.nativeElement.querySelector('.active')) {
+            this.renderer.addClass(this.element.nativeElement, 'df-sidenav-list-withactivated');
+        }
+        else {
+            this.renderer.removeClass(this.element.nativeElement, 'df-sidenav-list-withactivated');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfManageSideNavDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfManageSideNavDirective, isStandalone: true, selector: "[dfManageSideNav]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfManageSideNavDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dfManageSideNav]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuYWdlLXNpZGVuYXYuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGVzaWduLWZhY3Rvcnkvc3JjL2xpYi9hbmd1bGFyL3NpZGVuYXYvbWFuYWdlLXNpZGVuYXYuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBb0IsU0FBUyxFQUF5QixNQUFNLGVBQWUsQ0FBQzs7QUFNbkYsTUFBTSxPQUFPLHdCQUF3QjtJQUNuQyxZQUE2QixPQUFtQixFQUFtQixRQUFtQjtRQUF6RCxZQUFPLEdBQVAsT0FBTyxDQUFZO1FBQW1CLGFBQVEsR0FBUixRQUFRLENBQVc7SUFBRyxDQUFDO0lBRTFGLGtCQUFrQjtRQUNoQixJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUN2RCxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSwrQkFBK0IsQ0FBQyxDQUFDO1NBQ3JGO2FBQU07WUFDTCxJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSwrQkFBK0IsQ0FBQyxDQUFDO1NBQ3hGO0lBQ0gsQ0FBQzs4R0FUVSx3QkFBd0I7a0dBQXhCLHdCQUF3Qjs7MkZBQXhCLHdCQUF3QjtrQkFKcEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsbUJBQW1CO29CQUM3QixVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBZnRlclZpZXdDaGVja2VkLCBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIFJlbmRlcmVyMiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbZGZNYW5hZ2VTaWRlTmF2XScsXG4gIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgRGZNYW5hZ2VTaWRlTmF2RGlyZWN0aXZlIGltcGxlbWVudHMgQWZ0ZXJWaWV3Q2hlY2tlZCB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgZWxlbWVudDogRWxlbWVudFJlZiwgcHJpdmF0ZSByZWFkb25seSByZW5kZXJlcjogUmVuZGVyZXIyKSB7fVxuXG4gIG5nQWZ0ZXJWaWV3Q2hlY2tlZCgpIHtcbiAgICBpZiAodGhpcy5lbGVtZW50Lm5hdGl2ZUVsZW1lbnQucXVlcnlTZWxlY3RvcignLmFjdGl2ZScpKSB7XG4gICAgICB0aGlzLnJlbmRlcmVyLmFkZENsYXNzKHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LCAnZGYtc2lkZW5hdi1saXN0LXdpdGhhY3RpdmF0ZWQnKTtcbiAgICB9IGVsc2Uge1xuICAgICAgdGhpcy5yZW5kZXJlci5yZW1vdmVDbGFzcyh0aGlzLmVsZW1lbnQubmF0aXZlRWxlbWVudCwgJ2RmLXNpZGVuYXYtbGlzdC13aXRoYWN0aXZhdGVkJyk7XG4gICAgfVxuICB9XG59XG4iXX0=